net/disk_cache/v3/block_bitmaps.cc

   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 #include "net/disk_cache/block_files.h"
   6
   7 #include "base/atomicops.h"
   8 #include "base/file_util.h"
   9 #include "base/metrics/histogram.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/strings/stringprintf.h"
  12 #include "base/threading/thread_checker.h"
  13 #include "base/time/time.h"
  14 #include "net/disk_cache/cache_util.h"
  15 #include "net/disk_cache/file_lock.h"
  16 #include "net/disk_cache/trace.h"
  17
  18 using base::TimeTicks;
  19
  20 namespace disk_cache {
  21
  22 BlockFiles::BlockFiles(const base::FilePath& path)
  23     : init_(false), zero_buffer_(NULL), path_(path) {
  24 }
  25
  26 BlockFiles::~BlockFiles() {
  27   if (zero_buffer_)
  28     delete[] zero_buffer_;
  29   CloseFiles();
  30 }
  31
  32 bool BlockFiles::Init(bool create_files) {
  33   DCHECK(!init_);
  34   if (init_)
  35     return false;
  36
  37   thread_checker_.reset(new base::ThreadChecker);
  38
  39   block_files_.resize(kFirstAdditionalBlockFile);
  40   for (int i = 0; i < kFirstAdditionalBlockFile; i++) {
  41     if (create_files)
  42       if (!CreateBlockFile(i, static_cast<FileType>(i + 1), true))
  43         return false;
  44
  45     if (!OpenBlockFile(i))
  46       return false;
  47
  48     // Walk this chain of files removing empty ones.
  49     if (!RemoveEmptyFile(static_cast<FileType>(i + 1)))
  50       return false;
  51   }
  52
  53   init_ = true;
  54   return true;
  55 }
  56
  57 bool BlockFiles::CreateBlock(FileType block_type, int block_count,
  58                              Addr* block_address) {
  59   DCHECK(thread_checker_->CalledOnValidThread());
  60   if (block_type < RANKINGS || block_type > BLOCK_4K ||
  61       block_count < 1 || block_count > 4)
  62     return false;
  63   if (!init_)
  64     return false;
  65
  66   MappedFile* file = FileForNewBlock(block_type, block_count);
  67   if (!file)
  68     return false;
  69
  70   ScopedFlush flush(file);
  71   BlockFileHeader* header = reinterpret_cast<BlockFileHeader*>(file->buffer());
  72
  73   int target_size = 0;
  74   for (int i = block_count; i <= 4; i++) {
  75     if (header->empty[i - 1]) {
  76       target_size = i;
  77       break;
  78     }
  79   }
  80
  81   DCHECK(target_size);
  82   int index;
  83   if (!CreateMapBlock(target_size, block_count, header, &index))
  84     return false;
  85
  86   Addr address(block_type, block_count, header->this_file, index);
  87   block_address->set_value(address.value());
  88   Trace("CreateBlock 0x%x", address.value());
  89   return true;
  90 }
  91
  92 void BlockFiles::DeleteBlock(Addr address, bool deep) {
  93   DCHECK(thread_checker_->CalledOnValidThread());
  94   if (!address.is_initialized() || address.is_separate_file())
  95     return;
  96
  97   if (!zero_buffer_) {
  98     zero_buffer_ = new char[Addr::BlockSizeForFileType(BLOCK_4K) * 4];
  99     memset(zero_buffer_, 0, Addr::BlockSizeForFileType(BLOCK_4K) * 4);
 100   }
 101   MappedFile* file = GetFile(address);
 102   if (!file)
 103     return;
 104
 105   Trace("DeleteBlock 0x%x", address.value());
 106
 107   size_t size = address.BlockSize() * address.num_blocks();
 108   size_t offset = address.start_block() * address.BlockSize() +
 109                   kBlockHeaderSize;
 110   if (deep)
 111     file->Write(zero_buffer_, size, offset);
 112
 113   BlockFileHeader* header = reinterpret_cast<BlockFileHeader*>(file->buffer());
 114   DeleteMapBlock(address.start_block(), address.num_blocks(), header);
 115   file->Flush();
 116
 117   if (!header->num_entries) {
 118     // This file is now empty. Let's try to delete it.
 119     FileType type = Addr::RequiredFileType(header->entry_size);
 120     if (Addr::BlockSizeForFileType(RANKINGS) == header->entry_size)
 121       type = RANKINGS;
 122     RemoveEmptyFile(type);  // Ignore failures.
 123   }
 124 }
 125
 126 void BlockFiles::CloseFiles() {
 127   if (init_) {
 128     DCHECK(thread_checker_->CalledOnValidThread());
 129   }
 130   init_ = false;
 131   for (unsigned int i = 0; i < block_files_.size(); i++) {
 132     if (block_files_[i]) {
 133       block_files_[i]->Release();
 134       block_files_[i] = NULL;
 135     }
 136   }
 137   block_files_.clear();
 138 }
 139
 140 void BlockFiles::ReportStats() {
 141   DCHECK(thread_checker_->CalledOnValidThread());
 142   int used_blocks[kFirstAdditionalBlockFile];
 143   int load[kFirstAdditionalBlockFile];
 144   for (int i = 0; i < kFirstAdditionalBlockFile; i++) {
 145     GetFileStats(i, &used_blocks[i], &load[i]);
 146   }
 147   UMA_HISTOGRAM_COUNTS("DiskCache.Blocks_0", used_blocks[0]);
 148   UMA_HISTOGRAM_COUNTS("DiskCache.Blocks_1", used_blocks[1]);
 149   UMA_HISTOGRAM_COUNTS("DiskCache.Blocks_2", used_blocks[2]);
 150   UMA_HISTOGRAM_COUNTS("DiskCache.Blocks_3", used_blocks[3]);
 151
 152   UMA_HISTOGRAM_ENUMERATION("DiskCache.BlockLoad_0", load[0], 101);
 153   UMA_HISTOGRAM_ENUMERATION("DiskCache.BlockLoad_1", load[1], 101);
 154   UMA_HISTOGRAM_ENUMERATION("DiskCache.BlockLoad_2", load[2], 101);
 155   UMA_HISTOGRAM_ENUMERATION("DiskCache.BlockLoad_3", load[3], 101);
 156 }
 157
 158 bool BlockFiles::IsValid(Addr address) {
 159 #ifdef NDEBUG
 160   return true;
 161 #else
 162   if (!address.is_initialized() || address.is_separate_file())
 163     return false;
 164
 165   MappedFile* file = GetFile(address);
 166   if (!file)
 167     return false;
 168
 169   BlockFileHeader* header = reinterpret_cast<BlockFileHeader*>(file->buffer());
 170   bool rv = UsedMapBlock(address.start_block(), address.num_blocks(), header);
 171   DCHECK(rv);
 172
 173   static bool read_contents = false;
 174   if (read_contents) {
 175     scoped_ptr<char[]> buffer;
 176     buffer.reset(new char[Addr::BlockSizeForFileType(BLOCK_4K) * 4]);
 177     size_t size = address.BlockSize() * address.num_blocks();
 178     size_t offset = address.start_block() * address.BlockSize() +
 179                     kBlockHeaderSize;
 180     bool ok = file->Read(buffer.get(), size, offset);
 181     DCHECK(ok);
 182   }
 183
 184   return rv;
 185 #endif
 186 }
 187
 188 MappedFile* BlockFiles::GetFile(Addr address) {
 189   DCHECK(thread_checker_->CalledOnValidThread());
 190   DCHECK(block_files_.size() >= 4);
 191   DCHECK(address.is_block_file() || !address.is_initialized());
 192   if (!address.is_initialized())
 193     return NULL;
 194
 195   int file_index = address.FileNumber();
 196   if (static_cast<unsigned int>(file_index) >= block_files_.size() ||
 197       !block_files_[file_index]) {
 198     // We need to open the file
 199     if (!OpenBlockFile(file_index))
 200       return NULL;
 201   }
 202   DCHECK(block_files_.size() >= static_cast<unsigned int>(file_index));
 203   return block_files_[file_index];
 204 }
 205
 206 bool BlockFiles::GrowBlockFile(MappedFile* file, BlockFileHeader* header) {
 207   if (kMaxBlocks == header->max_entries)
 208     return false;
 209
 210   ScopedFlush flush(file);
 211   DCHECK(!header->empty[3]);
 212   int new_size = header->max_entries + 1024;
 213   if (new_size > kMaxBlocks)
 214     new_size = kMaxBlocks;
 215
 216   int new_size_bytes = new_size * header->entry_size + sizeof(*header);
 217
 218   if (!file->SetLength(new_size_bytes)) {
 219     // Most likely we are trying to truncate the file, so the header is wrong.
 220     if (header->updating < 10 && !FixBlockFileHeader(file)) {
 221       // If we can't fix the file increase the lock guard so we'll pick it on
 222       // the next start and replace it.
 223       header->updating = 100;
 224       return false;
 225     }
 226     return (header->max_entries >= new_size);
 227   }
 228
 229   FileLock lock(header);
 230   header->empty[3] = (new_size - header->max_entries) / 4;  // 4 blocks entries
 231   header->max_entries = new_size;
 232
 233   return true;
 234 }
 235
 236 MappedFile* BlockFiles::FileForNewBlock(FileType block_type, int block_count) {
 237   COMPILE_ASSERT(RANKINGS == 1, invalid_file_type);
 238   MappedFile* file = block_files_[block_type - 1];
 239   BlockFileHeader* header = reinterpret_cast<BlockFileHeader*>(file->buffer());
 240
 241   TimeTicks start = TimeTicks::Now();
 242   while (NeedToGrowBlockFile(header, block_count)) {
 243     if (kMaxBlocks == header->max_entries) {
 244       file = NextFile(file);
 245       if (!file)
 246         return NULL;
 247       header = reinterpret_cast<BlockFileHeader*>(file->buffer());
 248       continue;
 249     }
 250
 251     if (!GrowBlockFile(file, header))
 252       return NULL;
 253     break;
 254   }
 255   HISTOGRAM_TIMES("DiskCache.GetFileForNewBlock", TimeTicks::Now() - start);
 256   return file;
 257 }
 258
 259 // Note that we expect to be called outside of a FileLock... however, we cannot
 260 // DCHECK on header->updating because we may be fixing a crash.
 261 bool BlockFiles::FixBlockFileHeader(MappedFile* file) {
 262   ScopedFlush flush(file);
 263   BlockFileHeader* header = reinterpret_cast<BlockFileHeader*>(file->buffer());
 264   int file_size = static_cast<int>(file->GetLength());
 265   if (file_size < static_cast<int>(sizeof(*header)))
 266     return false;  // file_size > 2GB is also an error.
 267
 268   const int kMinBlockSize = 36;
 269   const int kMaxBlockSize = 4096;
 270   if (header->entry_size < kMinBlockSize ||
 271       header->entry_size > kMaxBlockSize || header->num_entries < 0)
 272     return false;
 273
 274   // Make sure that we survive crashes.
 275   header->updating = 1;
 276   int expected = header->entry_size * header->max_entries + sizeof(*header);
 277   if (file_size != expected) {
 278     int max_expected = header->entry_size * kMaxBlocks + sizeof(*header);
 279     if (file_size < expected || header->empty[3] || file_size > max_expected) {
 280       NOTREACHED();
 281       LOG(ERROR) << "Unexpected file size";
 282       return false;
 283     }
 284     // We were in the middle of growing the file.
 285     int num_entries = (file_size - sizeof(*header)) / header->entry_size;
 286     header->max_entries = num_entries;
 287   }
 288
 289   FixAllocationCounters(header);
 290   int empty_blocks = EmptyBlocks(header);
 291   if (empty_blocks + header->num_entries > header->max_entries)
 292     header->num_entries = header->max_entries - empty_blocks;
 293
 294   if (!ValidateCounters(header))
 295     return false;
 296
 297   header->updating = 0;
 298   return true;
 299 }
 300
 301 // We are interested in the total number of blocks used by this file type, and
 302 // the max number of blocks that we can store (reported as the percentage of
 303 // used blocks). In order to find out the number of used blocks, we have to
 304 // substract the empty blocks from the total blocks for each file in the chain.
 305 void BlockFiles::GetFileStats(int index, int* used_count, int* load) {
 306   int max_blocks = 0;
 307   *used_count = 0;
 308   *load = 0;
 309   for (;;) {
 310     if (!block_files_[index] && !OpenBlockFile(index))
 311       return;
 312
 313     BlockFileHeader* header =
 314         reinterpret_cast<BlockFileHeader*>(block_files_[index]->buffer());
 315
 316     max_blocks += header->max_entries;
 317     int used = header->max_entries;
 318     for (int i = 0; i < 4; i++) {
 319       used -= header->empty[i] * (i + 1);
 320       DCHECK_GE(used, 0);
 321     }
 322     *used_count += used;
 323
 324     if (!header->next_file)
 325       break;
 326     index = header->next_file;
 327   }
 328   if (max_blocks)
 329     *load = *used_count * 100 / max_blocks;
 330 }
 331
 332 }  // namespace disk_cache