Home | History | Annotate | Download | only in blockfile 
      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/blockfile/block_files.h"
      6 
      7 #include "base/atomicops.h"
      8 #include "base/files/file_path.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/blockfile/file_lock.h"
     15 #include "net/disk_cache/blockfile/stress_support.h"
     16 #include "net/disk_cache/blockfile/trace.h"
     17 #include "net/disk_cache/cache_util.h"
     18 
     19 using base::TimeTicks;
     20 
     21 namespace {
     22 
     23 const char* kBlockName = "data_";
     24 
     25 // This array is used to perform a fast lookup of the nibble bit pattern to the
     26 // type of entry that can be stored there (number of consecutive blocks).
     27 const char s_types[16] = {4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0};
     28 
     29 // Returns the type of block (number of consecutive blocks that can be stored)
     30 // for a given nibble of the bitmap.
     31 inline int GetMapBlockType(uint8 value) {
     32   value &= 0xf;
     33   return s_types[value];
     34 }
     35 
     36 }  // namespace
     37 
     38 namespace disk_cache {
     39 
     40 BlockHeader::BlockHeader() : header_(NULL) {
     41 }
     42 
     43 BlockHeader::BlockHeader(BlockFileHeader* header) : header_(header) {
     44 }
     45 
     46 BlockHeader::BlockHeader(MappedFile* file)
     47     : header_(reinterpret_cast<BlockFileHeader*>(file->buffer())) {
     48 }
     49 
     50 BlockHeader::BlockHeader(const BlockHeader& other) : header_(other.header_) {
     51 }
     52 
     53 BlockHeader::~BlockHeader() {
     54 }
     55 
     56 bool BlockHeader::CreateMapBlock(int size, int* index) {
     57   DCHECK(size > 0 && size <= kMaxNumBlocks);
     58   int target = 0;
     59   for (int i = size; i <= kMaxNumBlocks; i++) {
     60     if (header_->empty[i - 1]) {
     61       target = i;
     62       break;
     63     }
     64   }
     65 
     66   if (!target) {
     67     STRESS_NOTREACHED();
     68     return false;
     69   }
     70 
     71   TimeTicks start = TimeTicks::Now();
     72   // We are going to process the map on 32-block chunks (32 bits), and on every
     73   // chunk, iterate through the 8 nibbles where the new block can be located.
     74   int current = header_->hints[target - 1];
     75   for (int i = 0; i < header_->max_entries / 32; i++, current++) {
     76     if (current == header_->max_entries / 32)
     77       current = 0;
     78     uint32 map_block = header_->allocation_map[current];
     79 
     80     for (int j = 0; j < 8; j++, map_block >>= 4) {
     81       if (GetMapBlockType(map_block) != target)
     82         continue;
     83 
     84       disk_cache::FileLock lock(header_);
     85       int index_offset = j * 4 + 4 - target;
     86       *index = current * 32 + index_offset;
     87       STRESS_DCHECK(*index / 4 == (*index + size - 1) / 4);
     88       uint32 to_add = ((1 << size) - 1) << index_offset;
     89       header_->num_entries++;
     90 
     91       // Note that there is no race in the normal sense here, but if we enforce
     92       // the order of memory accesses between num_entries and allocation_map, we
     93       // can assert that even if we crash here, num_entries will never be less
     94       // than the actual number of used blocks.
     95       base::subtle::MemoryBarrier();
     96       header_->allocation_map[current] |= to_add;
     97 
     98       header_->hints[target - 1] = current;
     99       header_->empty[target - 1]--;
    100       STRESS_DCHECK(header_->empty[target - 1] >= 0);
    101       if (target != size) {
    102         header_->empty[target - size - 1]++;
    103       }
    104       LOCAL_HISTOGRAM_TIMES("DiskCache.CreateBlock", TimeTicks::Now() - start);
    105       return true;
    106     }
    107   }
    108 
    109   // It is possible to have an undetected corruption (for example when the OS
    110   // crashes), fix it here.
    111   LOG(ERROR) << "Failing CreateMapBlock";
    112   FixAllocationCounters();
    113   return false;
    114 }
    115 
    116 void BlockHeader::DeleteMapBlock(int index, int size) {
    117   if (size < 0 || size > kMaxNumBlocks) {
    118     NOTREACHED();
    119     return;
    120   }
    121   TimeTicks start = TimeTicks::Now();
    122   int byte_index = index / 8;
    123   uint8* byte_map = reinterpret_cast<uint8*>(header_->allocation_map);
    124   uint8 map_block = byte_map[byte_index];
    125 
    126   if (index % 8 >= 4)
    127     map_block >>= 4;
    128 
    129   // See what type of block will be available after we delete this one.
    130   int bits_at_end = 4 - size - index % 4;
    131   uint8 end_mask = (0xf << (4 - bits_at_end)) & 0xf;
    132   bool update_counters = (map_block & end_mask) == 0;
    133   uint8 new_value = map_block & ~(((1 << size) - 1) << (index % 4));
    134   int new_type = GetMapBlockType(new_value);
    135 
    136   disk_cache::FileLock lock(header_);
    137   STRESS_DCHECK((((1 << size) - 1) << (index % 8)) < 0x100);
    138   uint8  to_clear = ((1 << size) - 1) << (index % 8);
    139   STRESS_DCHECK((byte_map[byte_index] & to_clear) == to_clear);
    140   byte_map[byte_index] &= ~to_clear;
    141 
    142   if (update_counters) {
    143     if (bits_at_end)
    144       header_->empty[bits_at_end - 1]--;
    145     header_->empty[new_type - 1]++;
    146     STRESS_DCHECK(header_->empty[bits_at_end - 1] >= 0);
    147   }
    148   base::subtle::MemoryBarrier();
    149   header_->num_entries--;
    150   STRESS_DCHECK(header_->num_entries >= 0);
    151   LOCAL_HISTOGRAM_TIMES("DiskCache.DeleteBlock", TimeTicks::Now() - start);
    152 }
    153 
    154 // Note that this is a simplified version of DeleteMapBlock().
    155 bool BlockHeader::UsedMapBlock(int index, int size) {
    156   if (size < 0 || size > kMaxNumBlocks)
    157     return false;
    158 
    159   int byte_index = index / 8;
    160   uint8* byte_map = reinterpret_cast<uint8*>(header_->allocation_map);
    161   uint8 map_block = byte_map[byte_index];
    162 
    163   if (index % 8 >= 4)
    164     map_block >>= 4;
    165 
    166   STRESS_DCHECK((((1 << size) - 1) << (index % 8)) < 0x100);
    167   uint8  to_clear = ((1 << size) - 1) << (index % 8);
    168   return ((byte_map[byte_index] & to_clear) == to_clear);
    169 }
    170 
    171 void BlockHeader::FixAllocationCounters() {
    172   for (int i = 0; i < kMaxNumBlocks; i++) {
    173     header_->hints[i] = 0;
    174     header_->empty[i] = 0;
    175   }
    176 
    177   for (int i = 0; i < header_->max_entries / 32; i++) {
    178     uint32 map_block = header_->allocation_map[i];
    179 
    180     for (int j = 0; j < 8; j++, map_block >>= 4) {
    181       int type = GetMapBlockType(map_block);
    182       if (type)
    183         header_->empty[type -1]++;
    184     }
    185   }
    186 }
    187 
    188 bool BlockHeader::NeedToGrowBlockFile(int block_count) const {
    189   bool have_space = false;
    190   int empty_blocks = 0;
    191   for (int i = 0; i < kMaxNumBlocks; i++) {
    192     empty_blocks += header_->empty[i] * (i + 1);
    193     if (i >= block_count - 1 && header_->empty[i])
    194       have_space = true;
    195   }
    196 
    197   if (header_->next_file && (empty_blocks < kMaxBlocks / 10)) {
    198     // This file is almost full but we already created another one, don't use
    199     // this file yet so that it is easier to find empty blocks when we start
    200     // using this file again.
    201     return true;
    202   }
    203   return !have_space;
    204 }
    205 
    206 bool BlockHeader::CanAllocate(int block_count) const {
    207   DCHECK_GT(block_count, 0);
    208   for (int i = block_count - 1; i < kMaxNumBlocks; i++) {
    209     if (header_->empty[i])
    210       return true;
    211   }
    212 
    213   return false;
    214 }
    215 
    216 int BlockHeader::EmptyBlocks() const {
    217   int empty_blocks = 0;
    218   for (int i = 0; i < kMaxNumBlocks; i++) {
    219     empty_blocks += header_->empty[i] * (i + 1);
    220     if (header_->empty[i] < 0)
    221       return 0;
    222   }
    223   return empty_blocks;
    224 }
    225 
    226 int BlockHeader::MinimumAllocations() const {
    227   return header_->empty[kMaxNumBlocks - 1];
    228 }
    229 
    230 int BlockHeader::Capacity() const {
    231   return header_->max_entries;
    232 }
    233 
    234 bool BlockHeader::ValidateCounters() const {
    235   if (header_->max_entries < 0 || header_->max_entries > kMaxBlocks ||
    236       header_->num_entries < 0)
    237     return false;
    238 
    239   int empty_blocks = EmptyBlocks();
    240   if (empty_blocks + header_->num_entries > header_->max_entries)
    241     return false;
    242 
    243   return true;
    244 }
    245 
    246 int BlockHeader::FileId() const {
    247   return header_->this_file;
    248 }
    249 
    250 int BlockHeader::NextFileId() const {
    251   return header_->next_file;
    252 }
    253 
    254 int BlockHeader::Size() const {
    255   return static_cast<int>(sizeof(*header_));
    256 }
    257 
    258 BlockFileHeader* BlockHeader::Header() {
    259   return header_;
    260 }
    261 
    262 // ------------------------------------------------------------------------
    263 
    264 BlockFiles::BlockFiles(const base::FilePath& path)
    265     : init_(false), zero_buffer_(NULL), path_(path) {
    266 }
    267 
    268 BlockFiles::~BlockFiles() {
    269   if (zero_buffer_)
    270     delete[] zero_buffer_;
    271   CloseFiles();
    272 }
    273 
    274 bool BlockFiles::Init(bool create_files) {
    275   DCHECK(!init_);
    276   if (init_)
    277     return false;
    278 
    279   thread_checker_.reset(new base::ThreadChecker);
    280 
    281   block_files_.resize(kFirstAdditionalBlockFile);
    282   for (int i = 0; i < kFirstAdditionalBlockFile; i++) {
    283     if (create_files)
    284       if (!CreateBlockFile(i, static_cast<FileType>(i + 1), true))
    285         return false;
    286 
    287     if (!OpenBlockFile(i))
    288       return false;
    289 
    290     // Walk this chain of files removing empty ones.
    291     if (!RemoveEmptyFile(static_cast<FileType>(i + 1)))
    292       return false;
    293   }
    294 
    295   init_ = true;
    296   return true;
    297 }
    298 
    299 MappedFile* BlockFiles::GetFile(Addr address) {
    300   DCHECK(thread_checker_->CalledOnValidThread());
    301   DCHECK_GE(block_files_.size(),
    302             static_cast<size_t>(kFirstAdditionalBlockFile));
    303   DCHECK(address.is_block_file() || !address.is_initialized());
    304   if (!address.is_initialized())
    305     return NULL;
    306 
    307   int file_index = address.FileNumber();
    308   if (static_cast<unsigned int>(file_index) >= block_files_.size() ||
    309       !block_files_[file_index]) {
    310     // We need to open the file
    311     if (!OpenBlockFile(file_index))
    312       return NULL;
    313   }
    314   DCHECK_GE(block_files_.size(), static_cast<unsigned int>(file_index));
    315   return block_files_[file_index];
    316 }
    317 
    318 bool BlockFiles::CreateBlock(FileType block_type, int block_count,
    319                              Addr* block_address) {
    320   DCHECK(thread_checker_->CalledOnValidThread());
    321   DCHECK_NE(block_type, EXTERNAL);
    322   DCHECK_NE(block_type, BLOCK_FILES);
    323   DCHECK_NE(block_type, BLOCK_ENTRIES);
    324   DCHECK_NE(block_type, BLOCK_EVICTED);
    325   if (block_count < 1 || block_count > kMaxNumBlocks)
    326     return false;
    327 
    328   if (!init_)
    329     return false;
    330 
    331   MappedFile* file = FileForNewBlock(block_type, block_count);
    332   if (!file)
    333     return false;
    334 
    335   ScopedFlush flush(file);
    336   BlockHeader file_header(file);
    337 
    338   int index;
    339   if (!file_header.CreateMapBlock(block_count, &index))
    340     return false;
    341 
    342   Addr address(block_type, block_count, file_header.FileId(), index);
    343   block_address->set_value(address.value());
    344   Trace("CreateBlock 0x%x", address.value());
    345   return true;
    346 }
    347 
    348 void BlockFiles::DeleteBlock(Addr address, bool deep) {
    349   DCHECK(thread_checker_->CalledOnValidThread());
    350   if (!address.is_initialized() || address.is_separate_file())
    351     return;
    352 
    353   if (!zero_buffer_) {
    354     zero_buffer_ = new char[Addr::BlockSizeForFileType(BLOCK_4K) * 4];
    355     memset(zero_buffer_, 0, Addr::BlockSizeForFileType(BLOCK_4K) * 4);
    356   }
    357   MappedFile* file = GetFile(address);
    358   if (!file)
    359     return;
    360 
    361   Trace("DeleteBlock 0x%x", address.value());
    362 
    363   size_t size = address.BlockSize() * address.num_blocks();
    364   size_t offset = address.start_block() * address.BlockSize() +
    365                   kBlockHeaderSize;
    366   if (deep)
    367     file->Write(zero_buffer_, size, offset);
    368 
    369   BlockHeader file_header(file);
    370   file_header.DeleteMapBlock(address.start_block(), address.num_blocks());
    371   file->Flush();
    372 
    373   if (!file_header.Header()->num_entries) {
    374     // This file is now empty. Let's try to delete it.
    375     FileType type = Addr::RequiredFileType(file_header.Header()->entry_size);
    376     if (Addr::BlockSizeForFileType(RANKINGS) ==
    377         file_header.Header()->entry_size) {
    378       type = RANKINGS;
    379     }
    380     RemoveEmptyFile(type);  // Ignore failures.
    381   }
    382 }
    383 
    384 void BlockFiles::CloseFiles() {
    385   if (init_) {
    386     DCHECK(thread_checker_->CalledOnValidThread());
    387   }
    388   init_ = false;
    389   for (unsigned int i = 0; i < block_files_.size(); i++) {
    390     if (block_files_[i]) {
    391       block_files_[i]->Release();
    392       block_files_[i] = NULL;
    393     }
    394   }
    395   block_files_.clear();
    396 }
    397 
    398 void BlockFiles::ReportStats() {
    399   DCHECK(thread_checker_->CalledOnValidThread());
    400   int used_blocks[kFirstAdditionalBlockFile];
    401   int load[kFirstAdditionalBlockFile];
    402   for (int i = 0; i < kFirstAdditionalBlockFile; i++) {
    403     GetFileStats(i, &used_blocks[i], &load[i]);
    404   }
    405   UMA_HISTOGRAM_COUNTS("DiskCache.Blocks_0", used_blocks[0]);
    406   UMA_HISTOGRAM_COUNTS("DiskCache.Blocks_1", used_blocks[1]);
    407   UMA_HISTOGRAM_COUNTS("DiskCache.Blocks_2", used_blocks[2]);
    408   UMA_HISTOGRAM_COUNTS("DiskCache.Blocks_3", used_blocks[3]);
    409 
    410   UMA_HISTOGRAM_ENUMERATION("DiskCache.BlockLoad_0", load[0], 101);
    411   UMA_HISTOGRAM_ENUMERATION("DiskCache.BlockLoad_1", load[1], 101);
    412   UMA_HISTOGRAM_ENUMERATION("DiskCache.BlockLoad_2", load[2], 101);
    413   UMA_HISTOGRAM_ENUMERATION("DiskCache.BlockLoad_3", load[3], 101);
    414 }
    415 
    416 bool BlockFiles::IsValid(Addr address) {
    417 #ifdef NDEBUG
    418   return true;
    419 #else
    420   if (!address.is_initialized() || address.is_separate_file())
    421     return false;
    422 
    423   MappedFile* file = GetFile(address);
    424   if (!file)
    425     return false;
    426 
    427   BlockHeader header(file);
    428   bool rv = header.UsedMapBlock(address.start_block(), address.num_blocks());
    429   DCHECK(rv);
    430 
    431   static bool read_contents = false;
    432   if (read_contents) {
    433     scoped_ptr<char[]> buffer;
    434     buffer.reset(new char[Addr::BlockSizeForFileType(BLOCK_4K) * 4]);
    435     size_t size = address.BlockSize() * address.num_blocks();
    436     size_t offset = address.start_block() * address.BlockSize() +
    437                     kBlockHeaderSize;
    438     bool ok = file->Read(buffer.get(), size, offset);
    439     DCHECK(ok);
    440   }
    441 
    442   return rv;
    443 #endif
    444 }
    445 
    446 bool BlockFiles::CreateBlockFile(int index, FileType file_type, bool force) {
    447   base::FilePath name = Name(index);
    448   int flags = force ? base::File::FLAG_CREATE_ALWAYS : base::File::FLAG_CREATE;
    449   flags |= base::File::FLAG_WRITE | base::File::FLAG_EXCLUSIVE_WRITE;
    450 
    451   scoped_refptr<File> file(new File(base::File(name, flags)));
    452   if (!file->IsValid())
    453     return false;
    454 
    455   BlockFileHeader header;
    456   memset(&header, 0, sizeof(header));
    457   header.magic = kBlockMagic;
    458   header.version = kBlockVersion2;
    459   header.entry_size = Addr::BlockSizeForFileType(file_type);
    460   header.this_file = static_cast<int16>(index);
    461   DCHECK(index <= kint16max && index >= 0);
    462 
    463   return file->Write(&header, sizeof(header), 0);
    464 }
    465 
    466 bool BlockFiles::OpenBlockFile(int index) {
    467   if (block_files_.size() - 1 < static_cast<unsigned int>(index)) {
    468     DCHECK(index > 0);
    469     int to_add = index - static_cast<int>(block_files_.size()) + 1;
    470     block_files_.resize(block_files_.size() + to_add);
    471   }
    472 
    473   base::FilePath name = Name(index);
    474   scoped_refptr<MappedFile> file(new MappedFile());
    475 
    476   if (!file->Init(name, kBlockHeaderSize)) {
    477     LOG(ERROR) << "Failed to open " << name.value();
    478     return false;
    479   }
    480 
    481   size_t file_len = file->GetLength();
    482   if (file_len < static_cast<size_t>(kBlockHeaderSize)) {
    483     LOG(ERROR) << "File too small " << name.value();
    484     return false;
    485   }
    486 
    487   BlockHeader file_header(file.get());
    488   BlockFileHeader* header = file_header.Header();
    489   if (kBlockMagic != header->magic || kBlockVersion2 != header->version) {
    490     LOG(ERROR) << "Invalid file version or magic " << name.value();
    491     return false;
    492   }
    493 
    494   if (header->updating || !file_header.ValidateCounters()) {
    495     // Last instance was not properly shutdown, or counters are out of sync.
    496     if (!FixBlockFileHeader(file.get())) {
    497       LOG(ERROR) << "Unable to fix block file " << name.value();
    498       return false;
    499     }
    500   }
    501 
    502   if (static_cast<int>(file_len) <
    503       header->max_entries * header->entry_size + kBlockHeaderSize) {
    504     LOG(ERROR) << "File too small " << name.value();
    505     return false;
    506   }
    507 
    508   if (index == 0) {
    509     // Load the links file into memory.
    510     if (!file->Preload())
    511       return false;
    512   }
    513 
    514   ScopedFlush flush(file.get());
    515   DCHECK(!block_files_[index]);
    516   file.swap(&block_files_[index]);
    517   return true;
    518 }
    519 
    520 bool BlockFiles::GrowBlockFile(MappedFile* file, BlockFileHeader* header) {
    521   if (kMaxBlocks == header->max_entries)
    522     return false;
    523 
    524   ScopedFlush flush(file);
    525   DCHECK(!header->empty[3]);
    526   int new_size = header->max_entries + 1024;
    527   if (new_size > kMaxBlocks)
    528     new_size = kMaxBlocks;
    529 
    530   int new_size_bytes = new_size * header->entry_size + sizeof(*header);
    531 
    532   if (!file->SetLength(new_size_bytes)) {
    533     // Most likely we are trying to truncate the file, so the header is wrong.
    534     if (header->updating < 10 && !FixBlockFileHeader(file)) {
    535       // If we can't fix the file increase the lock guard so we'll pick it on
    536       // the next start and replace it.
    537       header->updating = 100;
    538       return false;
    539     }
    540     return (header->max_entries >= new_size);
    541   }
    542 
    543   FileLock lock(header);
    544   header->empty[3] = (new_size - header->max_entries) / 4;  // 4 blocks entries
    545   header->max_entries = new_size;
    546 
    547   return true;
    548 }
    549 
    550 MappedFile* BlockFiles::FileForNewBlock(FileType block_type, int block_count) {
    551   COMPILE_ASSERT(RANKINGS == 1, invalid_file_type);
    552   MappedFile* file = block_files_[block_type - 1];
    553   BlockHeader file_header(file);
    554 
    555   TimeTicks start = TimeTicks::Now();
    556   while (file_header.NeedToGrowBlockFile(block_count)) {
    557     if (kMaxBlocks == file_header.Header()->max_entries) {
    558       file = NextFile(file);
    559       if (!file)
    560         return NULL;
    561       file_header = BlockHeader(file);
    562       continue;
    563     }
    564 
    565     if (!GrowBlockFile(file, file_header.Header()))
    566       return NULL;
    567     break;
    568   }
    569   LOCAL_HISTOGRAM_TIMES("DiskCache.GetFileForNewBlock",
    570                         TimeTicks::Now() - start);
    571   return file;
    572 }
    573 
    574 MappedFile* BlockFiles::NextFile(MappedFile* file) {
    575   ScopedFlush flush(file);
    576   BlockFileHeader* header = reinterpret_cast<BlockFileHeader*>(file->buffer());
    577   int new_file = header->next_file;
    578   if (!new_file) {
    579     // RANKINGS is not reported as a type for small entries, but we may be
    580     // extending the rankings block file.
    581     FileType type = Addr::RequiredFileType(header->entry_size);
    582     if (header->entry_size == Addr::BlockSizeForFileType(RANKINGS))
    583       type = RANKINGS;
    584 
    585     new_file = CreateNextBlockFile(type);
    586     if (!new_file)
    587       return NULL;
    588 
    589     FileLock lock(header);
    590     header->next_file = new_file;
    591   }
    592 
    593   // Only the block_file argument is relevant for what we want.
    594   Addr address(BLOCK_256, 1, new_file, 0);
    595   return GetFile(address);
    596 }
    597 
    598 int BlockFiles::CreateNextBlockFile(FileType block_type) {
    599   for (int i = kFirstAdditionalBlockFile; i <= kMaxBlockFile; i++) {
    600     if (CreateBlockFile(i, block_type, false))
    601       return i;
    602   }
    603   return 0;
    604 }
    605 
    606 // We walk the list of files for this particular block type, deleting the ones
    607 // that are empty.
    608 bool BlockFiles::RemoveEmptyFile(FileType block_type) {
    609   MappedFile* file = block_files_[block_type - 1];
    610   BlockFileHeader* header = reinterpret_cast<BlockFileHeader*>(file->buffer());
    611 
    612   while (header->next_file) {
    613     // Only the block_file argument is relevant for what we want.
    614     Addr address(BLOCK_256, 1, header->next_file, 0);
    615     MappedFile* next_file = GetFile(address);
    616     if (!next_file)
    617       return false;
    618 
    619     BlockFileHeader* next_header =
    620         reinterpret_cast<BlockFileHeader*>(next_file->buffer());
    621     if (!next_header->num_entries) {
    622       DCHECK_EQ(next_header->entry_size, header->entry_size);
    623       // Delete next_file and remove it from the chain.
    624       int file_index = header->next_file;
    625       header->next_file = next_header->next_file;
    626       DCHECK(block_files_.size() >= static_cast<unsigned int>(file_index));
    627       file->Flush();
    628 
    629       // We get a new handle to the file and release the old one so that the
    630       // file gets unmmaped... so we can delete it.
    631       base::FilePath name = Name(file_index);
    632       scoped_refptr<File> this_file(new File(false));
    633       this_file->Init(name);
    634       block_files_[file_index]->Release();
    635       block_files_[file_index] = NULL;
    636 
    637       int failure = DeleteCacheFile(name) ? 0 : 1;
    638       UMA_HISTOGRAM_COUNTS("DiskCache.DeleteFailed2", failure);
    639       if (failure)
    640         LOG(ERROR) << "Failed to delete " << name.value() << " from the cache.";
    641       continue;
    642     }
    643 
    644     header = next_header;
    645     file = next_file;
    646   }
    647   return true;
    648 }
    649 
    650 // Note that we expect to be called outside of a FileLock... however, we cannot
    651 // DCHECK on header->updating because we may be fixing a crash.
    652 bool BlockFiles::FixBlockFileHeader(MappedFile* file) {
    653   ScopedFlush flush(file);
    654   BlockHeader file_header(file);
    655   int file_size = static_cast<int>(file->GetLength());
    656   if (file_size < file_header.Size())
    657     return false;  // file_size > 2GB is also an error.
    658 
    659   const int kMinBlockSize = 36;
    660   const int kMaxBlockSize = 4096;
    661   BlockFileHeader* header = file_header.Header();
    662   if (header->entry_size < kMinBlockSize ||
    663       header->entry_size > kMaxBlockSize || header->num_entries < 0)
    664     return false;
    665 
    666   // Make sure that we survive crashes.
    667   header->updating = 1;
    668   int expected = header->entry_size * header->max_entries + file_header.Size();
    669   if (file_size != expected) {
    670     int max_expected = header->entry_size * kMaxBlocks + file_header.Size();
    671     if (file_size < expected || header->empty[3] || file_size > max_expected) {
    672       NOTREACHED();
    673       LOG(ERROR) << "Unexpected file size";
    674       return false;
    675     }
    676     // We were in the middle of growing the file.
    677     int num_entries = (file_size - file_header.Size()) / header->entry_size;
    678     header->max_entries = num_entries;
    679   }
    680 
    681   file_header.FixAllocationCounters();
    682   int empty_blocks = file_header.EmptyBlocks();
    683   if (empty_blocks + header->num_entries > header->max_entries)
    684     header->num_entries = header->max_entries - empty_blocks;
    685 
    686   if (!file_header.ValidateCounters())
    687     return false;
    688 
    689   header->updating = 0;
    690   return true;
    691 }
    692 
    693 // We are interested in the total number of blocks used by this file type, and
    694 // the max number of blocks that we can store (reported as the percentage of
    695 // used blocks). In order to find out the number of used blocks, we have to
    696 // substract the empty blocks from the total blocks for each file in the chain.
    697 void BlockFiles::GetFileStats(int index, int* used_count, int* load) {
    698   int max_blocks = 0;
    699   *used_count = 0;
    700   *load = 0;
    701   for (;;) {
    702     if (!block_files_[index] && !OpenBlockFile(index))
    703       return;
    704 
    705     BlockFileHeader* header =
    706         reinterpret_cast<BlockFileHeader*>(block_files_[index]->buffer());
    707 
    708     max_blocks += header->max_entries;
    709     int used = header->max_entries;
    710     for (int i = 0; i < kMaxNumBlocks; i++) {
    711       used -= header->empty[i] * (i + 1);
    712       DCHECK_GE(used, 0);
    713     }
    714     *used_count += used;
    715 
    716     if (!header->next_file)
    717       break;
    718     index = header->next_file;
    719   }
    720   if (max_blocks)
    721     *load = *used_count * 100 / max_blocks;
    722 }
    723 
    724 base::FilePath BlockFiles::Name(int index) {
    725   // The file format allows for 256 files.
    726   DCHECK(index < 256 && index >= 0);
    727   std::string tmp = base::StringPrintf("%s%d", kBlockName, index);
    728   return path_.AppendASCII(tmp);
    729 }
    730 
    731 }  // namespace disk_cache
    732