1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // Performs basic inspection of the disk cache files with minimal disruption 6 // to the actual files (they still may change if an error is detected on the 7 // files). 8 9 #include "net/tools/dump_cache/dump_files.h" 10 11 #include <stdio.h> 12 13 #include <set> 14 #include <string> 15 16 #include "base/files/file.h" 17 #include "base/files/file_enumerator.h" 18 #include "base/files/file_util.h" 19 #include "base/format_macros.h" 20 #include "base/message_loop/message_loop.h" 21 #include "net/disk_cache/blockfile/block_files.h" 22 #include "net/disk_cache/blockfile/disk_format.h" 23 #include "net/disk_cache/blockfile/mapped_file.h" 24 #include "net/disk_cache/blockfile/stats.h" 25 #include "net/disk_cache/blockfile/storage_block-inl.h" 26 #include "net/disk_cache/blockfile/storage_block.h" 27 28 namespace { 29 30 const base::FilePath::CharType kIndexName[] = FILE_PATH_LITERAL("index"); 31 32 // Reads the |header_size| bytes from the beginning of file |name|. 33 bool ReadHeader(const base::FilePath& name, char* header, int header_size) { 34 base::File file(name, base::File::FLAG_OPEN | base::File::FLAG_READ); 35 if (!file.IsValid()) { 36 printf("Unable to open file %s\n", name.MaybeAsASCII().c_str()); 37 return false; 38 } 39 40 int read = file.Read(0, header, header_size); 41 if (read != header_size) { 42 printf("Unable to read file %s\n", name.MaybeAsASCII().c_str()); 43 return false; 44 } 45 return true; 46 } 47 48 int GetMajorVersionFromFile(const base::FilePath& name) { 49 disk_cache::IndexHeader header; 50 if (!ReadHeader(name, reinterpret_cast<char*>(&header), sizeof(header))) 51 return 0; 52 53 return header.version >> 16; 54 } 55 56 // Dumps the contents of the Stats record. 57 void DumpStats(const base::FilePath& path, disk_cache::CacheAddr addr) { 58 // We need a message loop, although we really don't run any task. 59 base::MessageLoopForIO loop; 60 61 disk_cache::BlockFiles block_files(path); 62 if (!block_files.Init(false)) { 63 printf("Unable to init block files\n"); 64 return; 65 } 66 67 disk_cache::Addr address(addr); 68 disk_cache::MappedFile* file = block_files.GetFile(address); 69 if (!file) 70 return; 71 72 size_t length = (2 + disk_cache::Stats::kDataSizesLength) * sizeof(int32) + 73 disk_cache::Stats::MAX_COUNTER * sizeof(int64); 74 75 size_t offset = address.start_block() * address.BlockSize() + 76 disk_cache::kBlockHeaderSize; 77 78 scoped_ptr<int32[]> buffer(new int32[length]); 79 if (!file->Read(buffer.get(), length, offset)) 80 return; 81 82 printf("Stats:\nSignatrure: 0x%x\n", buffer[0]); 83 printf("Total size: %d\n", buffer[1]); 84 for (int i = 0; i < disk_cache::Stats::kDataSizesLength; i++) 85 printf("Size(%d): %d\n", i, buffer[i + 2]); 86 87 int64* counters = reinterpret_cast<int64*>( 88 buffer.get() + 2 + disk_cache::Stats::kDataSizesLength); 89 for (int i = 0; i < disk_cache::Stats::MAX_COUNTER; i++) 90 printf("Count(%d): %" PRId64 "\n", i, *counters++); 91 printf("-------------------------\n\n"); 92 } 93 94 // Dumps the contents of the Index-file header. 95 void DumpIndexHeader(const base::FilePath& name, 96 disk_cache::CacheAddr* stats_addr) { 97 disk_cache::IndexHeader header; 98 if (!ReadHeader(name, reinterpret_cast<char*>(&header), sizeof(header))) 99 return; 100 101 printf("Index file:\n"); 102 printf("magic: %x\n", header.magic); 103 printf("version: %d.%d\n", header.version >> 16, header.version & 0xffff); 104 printf("entries: %d\n", header.num_entries); 105 printf("total bytes: %d\n", header.num_bytes); 106 printf("last file number: %d\n", header.last_file); 107 printf("current id: %d\n", header.this_id); 108 printf("table length: %d\n", header.table_len); 109 printf("last crash: %d\n", header.crash); 110 printf("experiment: %d\n", header.experiment); 111 printf("stats: %x\n", header.stats); 112 for (int i = 0; i < 5; i++) { 113 printf("head %d: 0x%x\n", i, header.lru.heads[i]); 114 printf("tail %d: 0x%x\n", i, header.lru.tails[i]); 115 printf("size %d: 0x%x\n", i, header.lru.sizes[i]); 116 } 117 printf("transaction: 0x%x\n", header.lru.transaction); 118 printf("operation: %d\n", header.lru.operation); 119 printf("operation list: %d\n", header.lru.operation_list); 120 printf("-------------------------\n\n"); 121 122 *stats_addr = header.stats; 123 } 124 125 // Dumps the contents of a block-file header. 126 void DumpBlockHeader(const base::FilePath& name) { 127 disk_cache::BlockFileHeader header; 128 if (!ReadHeader(name, reinterpret_cast<char*>(&header), sizeof(header))) 129 return; 130 131 printf("Block file: %s\n", name.BaseName().MaybeAsASCII().c_str()); 132 printf("magic: %x\n", header.magic); 133 printf("version: %d.%d\n", header.version >> 16, header.version & 0xffff); 134 printf("file id: %d\n", header.this_file); 135 printf("next file id: %d\n", header.next_file); 136 printf("entry size: %d\n", header.entry_size); 137 printf("current entries: %d\n", header.num_entries); 138 printf("max entries: %d\n", header.max_entries); 139 printf("updating: %d\n", header.updating); 140 printf("empty sz 1: %d\n", header.empty[0]); 141 printf("empty sz 2: %d\n", header.empty[1]); 142 printf("empty sz 3: %d\n", header.empty[2]); 143 printf("empty sz 4: %d\n", header.empty[3]); 144 printf("user 0: 0x%x\n", header.user[0]); 145 printf("user 1: 0x%x\n", header.user[1]); 146 printf("user 2: 0x%x\n", header.user[2]); 147 printf("user 3: 0x%x\n", header.user[3]); 148 printf("-------------------------\n\n"); 149 } 150 151 // Simple class that interacts with the set of cache files. 152 class CacheDumper { 153 public: 154 explicit CacheDumper(const base::FilePath& path) 155 : path_(path), 156 block_files_(path), 157 index_(NULL), 158 current_hash_(0), 159 next_addr_(0) { 160 } 161 162 bool Init(); 163 164 // Reads an entry from disk. Return false when all entries have been already 165 // returned. 166 bool GetEntry(disk_cache::EntryStore* entry); 167 168 // Loads a specific block from the block files. 169 bool LoadEntry(disk_cache::CacheAddr addr, disk_cache::EntryStore* entry); 170 bool LoadRankings(disk_cache::CacheAddr addr, 171 disk_cache::RankingsNode* rankings); 172 173 private: 174 base::FilePath path_; 175 disk_cache::BlockFiles block_files_; 176 scoped_refptr<disk_cache::MappedFile> index_file_; 177 disk_cache::Index* index_; 178 int current_hash_; 179 disk_cache::CacheAddr next_addr_; 180 std::set<disk_cache::CacheAddr> dumped_entries_; 181 DISALLOW_COPY_AND_ASSIGN(CacheDumper); 182 }; 183 184 bool CacheDumper::Init() { 185 if (!block_files_.Init(false)) { 186 printf("Unable to init block files\n"); 187 return false; 188 } 189 190 base::FilePath index_name(path_.Append(kIndexName)); 191 index_file_ = new disk_cache::MappedFile; 192 index_ = reinterpret_cast<disk_cache::Index*>( 193 index_file_->Init(index_name, 0)); 194 if (!index_) { 195 printf("Unable to map index\n"); 196 return false; 197 } 198 199 return true; 200 } 201 202 bool CacheDumper::GetEntry(disk_cache::EntryStore* entry) { 203 if (dumped_entries_.find(next_addr_) != dumped_entries_.end()) { 204 printf("Loop detected\n"); 205 next_addr_ = 0; 206 current_hash_++; 207 } 208 209 if (next_addr_) { 210 if (LoadEntry(next_addr_, entry)) 211 return true; 212 213 printf("Unable to load entry at address 0x%x\n", next_addr_); 214 next_addr_ = 0; 215 current_hash_++; 216 } 217 218 for (int i = current_hash_; i < index_->header.table_len; i++) { 219 // Yes, we'll crash if the table is shorter than expected, but only after 220 // dumping every entry that we can find. 221 if (index_->table[i]) { 222 current_hash_ = i; 223 if (LoadEntry(index_->table[i], entry)) 224 return true; 225 226 printf("Unable to load entry at address 0x%x\n", index_->table[i]); 227 } 228 } 229 return false; 230 } 231 232 bool CacheDumper::LoadEntry(disk_cache::CacheAddr addr, 233 disk_cache::EntryStore* entry) { 234 disk_cache::Addr address(addr); 235 disk_cache::MappedFile* file = block_files_.GetFile(address); 236 if (!file) 237 return false; 238 239 disk_cache::StorageBlock<disk_cache::EntryStore> entry_block(file, address); 240 if (!entry_block.Load()) 241 return false; 242 243 memcpy(entry, entry_block.Data(), sizeof(*entry)); 244 printf("Entry at 0x%x\n", addr); 245 246 // Prepare for the next entry to load. 247 next_addr_ = entry->next; 248 if (next_addr_) { 249 dumped_entries_.insert(addr); 250 } else { 251 current_hash_++; 252 dumped_entries_.clear(); 253 } 254 return true; 255 } 256 257 bool CacheDumper::LoadRankings(disk_cache::CacheAddr addr, 258 disk_cache::RankingsNode* rankings) { 259 disk_cache::Addr address(addr); 260 disk_cache::MappedFile* file = block_files_.GetFile(address); 261 if (!file) 262 return false; 263 264 disk_cache::StorageBlock<disk_cache::RankingsNode> rank_block(file, address); 265 if (!rank_block.Load()) 266 return false; 267 268 memcpy(rankings, rank_block.Data(), sizeof(*rankings)); 269 printf("Rankings at 0x%x\n", addr); 270 return true; 271 } 272 273 void DumpEntry(const disk_cache::EntryStore& entry) { 274 std::string key; 275 if (!entry.long_key) { 276 key = entry.key; 277 if (key.size() > 50) 278 key.resize(50); 279 } 280 281 printf("hash: 0x%x\n", entry.hash); 282 printf("next entry: 0x%x\n", entry.next); 283 printf("rankings: 0x%x\n", entry.rankings_node); 284 printf("key length: %d\n", entry.key_len); 285 printf("key: \"%s\"\n", key.c_str()); 286 printf("key addr: 0x%x\n", entry.long_key); 287 printf("reuse count: %d\n", entry.reuse_count); 288 printf("refetch count: %d\n", entry.refetch_count); 289 printf("state: %d\n", entry.state); 290 for (int i = 0; i < 4; i++) { 291 printf("data size %d: %d\n", i, entry.data_size[i]); 292 printf("data addr %d: 0x%x\n", i, entry.data_addr[i]); 293 } 294 printf("----------\n\n"); 295 } 296 297 void DumpRankings(const disk_cache::RankingsNode& rankings) { 298 printf("next: 0x%x\n", rankings.next); 299 printf("prev: 0x%x\n", rankings.prev); 300 printf("entry: 0x%x\n", rankings.contents); 301 printf("dirty: %d\n", rankings.dirty); 302 printf("hash: 0x%x\n", rankings.self_hash); 303 printf("----------\n\n"); 304 } 305 306 } // namespace. 307 308 // ----------------------------------------------------------------------- 309 310 int GetMajorVersion(const base::FilePath& input_path) { 311 base::FilePath index_name(input_path.Append(kIndexName)); 312 313 int version = GetMajorVersionFromFile(index_name); 314 if (!version) 315 return 0; 316 317 base::FilePath data_name(input_path.Append(FILE_PATH_LITERAL("data_0"))); 318 if (version != GetMajorVersionFromFile(data_name)) 319 return 0; 320 321 data_name = input_path.Append(FILE_PATH_LITERAL("data_1")); 322 if (version != GetMajorVersionFromFile(data_name)) 323 return 0; 324 325 data_name = input_path.Append(FILE_PATH_LITERAL("data_2")); 326 if (version != GetMajorVersionFromFile(data_name)) 327 return 0; 328 329 data_name = input_path.Append(FILE_PATH_LITERAL("data_3")); 330 if (version != GetMajorVersionFromFile(data_name)) 331 return 0; 332 333 return version; 334 } 335 336 // Dumps the headers of all files. 337 int DumpHeaders(const base::FilePath& input_path) { 338 base::FilePath index_name(input_path.Append(kIndexName)); 339 disk_cache::CacheAddr stats_addr = 0; 340 DumpIndexHeader(index_name, &stats_addr); 341 342 base::FileEnumerator iter(input_path, false, 343 base::FileEnumerator::FILES, 344 FILE_PATH_LITERAL("data_*")); 345 for (base::FilePath file = iter.Next(); !file.empty(); file = iter.Next()) 346 DumpBlockHeader(file); 347 348 DumpStats(input_path, stats_addr); 349 return 0; 350 } 351 352 // Dumps all entries from the cache. 353 int DumpContents(const base::FilePath& input_path) { 354 DumpHeaders(input_path); 355 356 // We need a message loop, although we really don't run any task. 357 base::MessageLoopForIO loop; 358 CacheDumper dumper(input_path); 359 if (!dumper.Init()) 360 return -1; 361 362 disk_cache::EntryStore entry; 363 while (dumper.GetEntry(&entry)) { 364 DumpEntry(entry); 365 disk_cache::RankingsNode rankings; 366 if (dumper.LoadRankings(entry.rankings_node, &rankings)) 367 DumpRankings(rankings); 368 } 369 370 printf("Done.\n"); 371 372 return 0; 373 } 374
