diff options
Diffstat (limited to 'chromium/net/disk_cache/entry_impl.cc')
| -rw-r--r-- | chromium/net/disk_cache/entry_impl.cc | 1550 |
1 files changed, 1550 insertions, 0 deletions
diff --git a/chromium/net/disk_cache/entry_impl.cc b/chromium/net/disk_cache/entry_impl.cc new file mode 100644 index 00000000000..4b6e4cf2b04 --- /dev/null +++ b/chromium/net/disk_cache/entry_impl.cc @@ -0,0 +1,1550 @@ +// 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. + +#include "net/disk_cache/entry_impl.h" + +#include "base/hash.h" +#include "base/message_loop/message_loop.h" +#include "base/metrics/histogram.h" +#include "base/strings/string_util.h" +#include "net/base/io_buffer.h" +#include "net/base/net_errors.h" +#include "net/disk_cache/backend_impl.h" +#include "net/disk_cache/bitmap.h" +#include "net/disk_cache/cache_util.h" +#include "net/disk_cache/disk_format.h" +#include "net/disk_cache/histogram_macros.h" +#include "net/disk_cache/net_log_parameters.h" +#include "net/disk_cache/sparse_control.h" + +using base::Time; +using base::TimeDelta; +using base::TimeTicks; + +namespace { + +// Index for the file used to store the key, if any (files_[kKeyFileIndex]). +const int kKeyFileIndex = 3; + +// This class implements FileIOCallback to buffer the callback from a file IO +// operation from the actual net class. +class SyncCallback: public disk_cache::FileIOCallback { + public: + // |end_event_type| is the event type to log on completion. Logs nothing on + // discard, or when the NetLog is not set to log all events. + SyncCallback(disk_cache::EntryImpl* entry, net::IOBuffer* buffer, + const net::CompletionCallback& callback, + net::NetLog::EventType end_event_type) + : entry_(entry), callback_(callback), buf_(buffer), + start_(TimeTicks::Now()), end_event_type_(end_event_type) { + entry->AddRef(); + entry->IncrementIoCount(); + } + virtual ~SyncCallback() {} + + virtual void OnFileIOComplete(int bytes_copied) OVERRIDE; + void Discard(); + + private: + disk_cache::EntryImpl* entry_; + net::CompletionCallback callback_; + scoped_refptr<net::IOBuffer> buf_; + TimeTicks start_; + const net::NetLog::EventType end_event_type_; + + DISALLOW_COPY_AND_ASSIGN(SyncCallback); +}; + +void SyncCallback::OnFileIOComplete(int bytes_copied) { + entry_->DecrementIoCount(); + if (!callback_.is_null()) { + if (entry_->net_log().IsLoggingAllEvents()) { + entry_->net_log().EndEvent( + end_event_type_, + disk_cache::CreateNetLogReadWriteCompleteCallback(bytes_copied)); + } + entry_->ReportIOTime(disk_cache::EntryImpl::kAsyncIO, start_); + buf_ = NULL; // Release the buffer before invoking the callback. + callback_.Run(bytes_copied); + } + entry_->Release(); + delete this; +} + +void SyncCallback::Discard() { + callback_.Reset(); + buf_ = NULL; + OnFileIOComplete(0); +} + +const int kMaxBufferSize = 1024 * 1024; // 1 MB. + +} // namespace + +namespace disk_cache { + +// This class handles individual memory buffers that store data before it is +// sent to disk. The buffer can start at any offset, but if we try to write to +// anywhere in the first 16KB of the file (kMaxBlockSize), we set the offset to +// zero. The buffer grows up to a size determined by the backend, to keep the +// total memory used under control. +class EntryImpl::UserBuffer { + public: + explicit UserBuffer(BackendImpl* backend) + : backend_(backend->GetWeakPtr()), offset_(0), grow_allowed_(true) { + buffer_.reserve(kMaxBlockSize); + } + ~UserBuffer() { + if (backend_.get()) + backend_->BufferDeleted(capacity() - kMaxBlockSize); + } + + // Returns true if we can handle writing |len| bytes to |offset|. + bool PreWrite(int offset, int len); + + // Truncates the buffer to |offset| bytes. + void Truncate(int offset); + + // Writes |len| bytes from |buf| at the given |offset|. + void Write(int offset, IOBuffer* buf, int len); + + // Returns true if we can read |len| bytes from |offset|, given that the + // actual file has |eof| bytes stored. Note that the number of bytes to read + // may be modified by this method even though it returns false: that means we + // should do a smaller read from disk. + bool PreRead(int eof, int offset, int* len); + + // Read |len| bytes from |buf| at the given |offset|. + int Read(int offset, IOBuffer* buf, int len); + + // Prepare this buffer for reuse. + void Reset(); + + char* Data() { return buffer_.size() ? &buffer_[0] : NULL; } + int Size() { return static_cast<int>(buffer_.size()); } + int Start() { return offset_; } + int End() { return offset_ + Size(); } + + private: + int capacity() { return static_cast<int>(buffer_.capacity()); } + bool GrowBuffer(int required, int limit); + + base::WeakPtr<BackendImpl> backend_; + int offset_; + std::vector<char> buffer_; + bool grow_allowed_; + DISALLOW_COPY_AND_ASSIGN(UserBuffer); +}; + +bool EntryImpl::UserBuffer::PreWrite(int offset, int len) { + DCHECK_GE(offset, 0); + DCHECK_GE(len, 0); + DCHECK_GE(offset + len, 0); + + // We don't want to write before our current start. + if (offset < offset_) + return false; + + // Lets get the common case out of the way. + if (offset + len <= capacity()) + return true; + + // If we are writing to the first 16K (kMaxBlockSize), we want to keep the + // buffer offset_ at 0. + if (!Size() && offset > kMaxBlockSize) + return GrowBuffer(len, kMaxBufferSize); + + int required = offset - offset_ + len; + return GrowBuffer(required, kMaxBufferSize * 6 / 5); +} + +void EntryImpl::UserBuffer::Truncate(int offset) { + DCHECK_GE(offset, 0); + DCHECK_GE(offset, offset_); + DVLOG(3) << "Buffer truncate at " << offset << " current " << offset_; + + offset -= offset_; + if (Size() >= offset) + buffer_.resize(offset); +} + +void EntryImpl::UserBuffer::Write(int offset, IOBuffer* buf, int len) { + DCHECK_GE(offset, 0); + DCHECK_GE(len, 0); + DCHECK_GE(offset + len, 0); + DCHECK_GE(offset, offset_); + DVLOG(3) << "Buffer write at " << offset << " current " << offset_; + + if (!Size() && offset > kMaxBlockSize) + offset_ = offset; + + offset -= offset_; + + if (offset > Size()) + buffer_.resize(offset); + + if (!len) + return; + + char* buffer = buf->data(); + int valid_len = Size() - offset; + int copy_len = std::min(valid_len, len); + if (copy_len) { + memcpy(&buffer_[offset], buffer, copy_len); + len -= copy_len; + buffer += copy_len; + } + if (!len) + return; + + buffer_.insert(buffer_.end(), buffer, buffer + len); +} + +bool EntryImpl::UserBuffer::PreRead(int eof, int offset, int* len) { + DCHECK_GE(offset, 0); + DCHECK_GT(*len, 0); + + if (offset < offset_) { + // We are reading before this buffer. + if (offset >= eof) + return true; + + // If the read overlaps with the buffer, change its length so that there is + // no overlap. + *len = std::min(*len, offset_ - offset); + *len = std::min(*len, eof - offset); + + // We should read from disk. + return false; + } + + if (!Size()) + return false; + + // See if we can fulfill the first part of the operation. + return (offset - offset_ < Size()); +} + +int EntryImpl::UserBuffer::Read(int offset, IOBuffer* buf, int len) { + DCHECK_GE(offset, 0); + DCHECK_GT(len, 0); + DCHECK(Size() || offset < offset_); + + int clean_bytes = 0; + if (offset < offset_) { + // We don't have a file so lets fill the first part with 0. + clean_bytes = std::min(offset_ - offset, len); + memset(buf->data(), 0, clean_bytes); + if (len == clean_bytes) + return len; + offset = offset_; + len -= clean_bytes; + } + + int start = offset - offset_; + int available = Size() - start; + DCHECK_GE(start, 0); + DCHECK_GE(available, 0); + len = std::min(len, available); + memcpy(buf->data() + clean_bytes, &buffer_[start], len); + return len + clean_bytes; +} + +void EntryImpl::UserBuffer::Reset() { + if (!grow_allowed_) { + if (backend_.get()) + backend_->BufferDeleted(capacity() - kMaxBlockSize); + grow_allowed_ = true; + std::vector<char> tmp; + buffer_.swap(tmp); + buffer_.reserve(kMaxBlockSize); + } + offset_ = 0; + buffer_.clear(); +} + +bool EntryImpl::UserBuffer::GrowBuffer(int required, int limit) { + DCHECK_GE(required, 0); + int current_size = capacity(); + if (required <= current_size) + return true; + + if (required > limit) + return false; + + if (!backend_.get()) + return false; + + int to_add = std::max(required - current_size, kMaxBlockSize * 4); + to_add = std::max(current_size, to_add); + required = std::min(current_size + to_add, limit); + + grow_allowed_ = backend_->IsAllocAllowed(current_size, required); + if (!grow_allowed_) + return false; + + DVLOG(3) << "Buffer grow to " << required; + + buffer_.reserve(required); + return true; +} + +// ------------------------------------------------------------------------ + +EntryImpl::EntryImpl(BackendImpl* backend, Addr address, bool read_only) + : entry_(NULL, Addr(0)), node_(NULL, Addr(0)), + backend_(backend->GetWeakPtr()), doomed_(false), read_only_(read_only), + dirty_(false) { + entry_.LazyInit(backend->File(address), address); + for (int i = 0; i < kNumStreams; i++) { + unreported_size_[i] = 0; + } +} + +void EntryImpl::DoomImpl() { + if (doomed_ || !backend_.get()) + return; + + SetPointerForInvalidEntry(backend_->GetCurrentEntryId()); + backend_->InternalDoomEntry(this); +} + +int EntryImpl::ReadDataImpl(int index, int offset, IOBuffer* buf, int buf_len, + const CompletionCallback& callback) { + if (net_log_.IsLoggingAllEvents()) { + net_log_.BeginEvent( + net::NetLog::TYPE_ENTRY_READ_DATA, + CreateNetLogReadWriteDataCallback(index, offset, buf_len, false)); + } + + int result = InternalReadData(index, offset, buf, buf_len, callback); + + if (result != net::ERR_IO_PENDING && net_log_.IsLoggingAllEvents()) { + net_log_.EndEvent( + net::NetLog::TYPE_ENTRY_READ_DATA, + CreateNetLogReadWriteCompleteCallback(result)); + } + return result; +} + +int EntryImpl::WriteDataImpl(int index, int offset, IOBuffer* buf, int buf_len, + const CompletionCallback& callback, + bool truncate) { + if (net_log_.IsLoggingAllEvents()) { + net_log_.BeginEvent( + net::NetLog::TYPE_ENTRY_WRITE_DATA, + CreateNetLogReadWriteDataCallback(index, offset, buf_len, truncate)); + } + + int result = InternalWriteData(index, offset, buf, buf_len, callback, + truncate); + + if (result != net::ERR_IO_PENDING && net_log_.IsLoggingAllEvents()) { + net_log_.EndEvent( + net::NetLog::TYPE_ENTRY_WRITE_DATA, + CreateNetLogReadWriteCompleteCallback(result)); + } + return result; +} + +int EntryImpl::ReadSparseDataImpl(int64 offset, IOBuffer* buf, int buf_len, + const CompletionCallback& callback) { + DCHECK(node_.Data()->dirty || read_only_); + int result = InitSparseData(); + if (net::OK != result) + return result; + + TimeTicks start = TimeTicks::Now(); + result = sparse_->StartIO(SparseControl::kReadOperation, offset, buf, buf_len, + callback); + ReportIOTime(kSparseRead, start); + return result; +} + +int EntryImpl::WriteSparseDataImpl(int64 offset, IOBuffer* buf, int buf_len, + const CompletionCallback& callback) { + DCHECK(node_.Data()->dirty || read_only_); + int result = InitSparseData(); + if (net::OK != result) + return result; + + TimeTicks start = TimeTicks::Now(); + result = sparse_->StartIO(SparseControl::kWriteOperation, offset, buf, + buf_len, callback); + ReportIOTime(kSparseWrite, start); + return result; +} + +int EntryImpl::GetAvailableRangeImpl(int64 offset, int len, int64* start) { + int result = InitSparseData(); + if (net::OK != result) + return result; + + return sparse_->GetAvailableRange(offset, len, start); +} + +void EntryImpl::CancelSparseIOImpl() { + if (!sparse_.get()) + return; + + sparse_->CancelIO(); +} + +int EntryImpl::ReadyForSparseIOImpl(const CompletionCallback& callback) { + DCHECK(sparse_.get()); + return sparse_->ReadyToUse(callback); +} + +uint32 EntryImpl::GetHash() { + return entry_.Data()->hash; +} + +bool EntryImpl::CreateEntry(Addr node_address, const std::string& key, + uint32 hash) { + Trace("Create entry In"); + EntryStore* entry_store = entry_.Data(); + RankingsNode* node = node_.Data(); + memset(entry_store, 0, sizeof(EntryStore) * entry_.address().num_blocks()); + memset(node, 0, sizeof(RankingsNode)); + if (!node_.LazyInit(backend_->File(node_address), node_address)) + return false; + + entry_store->rankings_node = node_address.value(); + node->contents = entry_.address().value(); + + entry_store->hash = hash; + entry_store->creation_time = Time::Now().ToInternalValue(); + entry_store->key_len = static_cast<int32>(key.size()); + if (entry_store->key_len > kMaxInternalKeyLength) { + Addr address(0); + if (!CreateBlock(entry_store->key_len + 1, &address)) + return false; + + entry_store->long_key = address.value(); + File* key_file = GetBackingFile(address, kKeyFileIndex); + key_ = key; + + size_t offset = 0; + if (address.is_block_file()) + offset = address.start_block() * address.BlockSize() + kBlockHeaderSize; + + if (!key_file || !key_file->Write(key.data(), key.size(), offset)) { + DeleteData(address, kKeyFileIndex); + return false; + } + + if (address.is_separate_file()) + key_file->SetLength(key.size() + 1); + } else { + memcpy(entry_store->key, key.data(), key.size()); + entry_store->key[key.size()] = '\0'; + } + backend_->ModifyStorageSize(0, static_cast<int32>(key.size())); + CACHE_UMA(COUNTS, "KeySize", 0, static_cast<int32>(key.size())); + node->dirty = backend_->GetCurrentEntryId(); + Log("Create Entry "); + return true; +} + +bool EntryImpl::IsSameEntry(const std::string& key, uint32 hash) { + if (entry_.Data()->hash != hash || + static_cast<size_t>(entry_.Data()->key_len) != key.size()) + return false; + + return (key.compare(GetKey()) == 0); +} + +void EntryImpl::InternalDoom() { + net_log_.AddEvent(net::NetLog::TYPE_ENTRY_DOOM); + DCHECK(node_.HasData()); + if (!node_.Data()->dirty) { + node_.Data()->dirty = backend_->GetCurrentEntryId(); + node_.Store(); + } + doomed_ = true; +} + +void EntryImpl::DeleteEntryData(bool everything) { + DCHECK(doomed_ || !everything); + + if (GetEntryFlags() & PARENT_ENTRY) { + // We have some child entries that must go away. + SparseControl::DeleteChildren(this); + } + + if (GetDataSize(0)) + CACHE_UMA(COUNTS, "DeleteHeader", 0, GetDataSize(0)); + if (GetDataSize(1)) + CACHE_UMA(COUNTS, "DeleteData", 0, GetDataSize(1)); + for (int index = 0; index < kNumStreams; index++) { + Addr address(entry_.Data()->data_addr[index]); + if (address.is_initialized()) { + backend_->ModifyStorageSize(entry_.Data()->data_size[index] - + unreported_size_[index], 0); + entry_.Data()->data_addr[index] = 0; + entry_.Data()->data_size[index] = 0; + entry_.Store(); + DeleteData(address, index); + } + } + + if (!everything) + return; + + // Remove all traces of this entry. + backend_->RemoveEntry(this); + + // Note that at this point node_ and entry_ are just two blocks of data, and + // even if they reference each other, nobody should be referencing them. + + Addr address(entry_.Data()->long_key); + DeleteData(address, kKeyFileIndex); + backend_->ModifyStorageSize(entry_.Data()->key_len, 0); + + backend_->DeleteBlock(entry_.address(), true); + entry_.Discard(); + + if (!LeaveRankingsBehind()) { + backend_->DeleteBlock(node_.address(), true); + node_.Discard(); + } +} + +CacheAddr EntryImpl::GetNextAddress() { + return entry_.Data()->next; +} + +void EntryImpl::SetNextAddress(Addr address) { + DCHECK_NE(address.value(), entry_.address().value()); + entry_.Data()->next = address.value(); + bool success = entry_.Store(); + DCHECK(success); +} + +bool EntryImpl::LoadNodeAddress() { + Addr address(entry_.Data()->rankings_node); + if (!node_.LazyInit(backend_->File(address), address)) + return false; + return node_.Load(); +} + +bool EntryImpl::Update() { + DCHECK(node_.HasData()); + + if (read_only_) + return true; + + RankingsNode* rankings = node_.Data(); + if (!rankings->dirty) { + rankings->dirty = backend_->GetCurrentEntryId(); + if (!node_.Store()) + return false; + } + return true; +} + +void EntryImpl::SetDirtyFlag(int32 current_id) { + DCHECK(node_.HasData()); + if (node_.Data()->dirty && current_id != node_.Data()->dirty) + dirty_ = true; + + if (!current_id) + dirty_ = true; +} + +void EntryImpl::SetPointerForInvalidEntry(int32 new_id) { + node_.Data()->dirty = new_id; + node_.Store(); +} + +bool EntryImpl::LeaveRankingsBehind() { + return !node_.Data()->contents; +} + +// This only includes checks that relate to the first block of the entry (the +// first 256 bytes), and values that should be set from the entry creation. +// Basically, even if there is something wrong with this entry, we want to see +// if it is possible to load the rankings node and delete them together. +bool EntryImpl::SanityCheck() { + if (!entry_.VerifyHash()) + return false; + + EntryStore* stored = entry_.Data(); + if (!stored->rankings_node || stored->key_len <= 0) + return false; + + if (stored->reuse_count < 0 || stored->refetch_count < 0) + return false; + + Addr rankings_addr(stored->rankings_node); + if (!rankings_addr.SanityCheckForRankings()) + return false; + + Addr next_addr(stored->next); + if (next_addr.is_initialized() && !next_addr.SanityCheckForEntryV2()) { + STRESS_NOTREACHED(); + return false; + } + STRESS_DCHECK(next_addr.value() != entry_.address().value()); + + if (stored->state > ENTRY_DOOMED || stored->state < ENTRY_NORMAL) + return false; + + Addr key_addr(stored->long_key); + if ((stored->key_len <= kMaxInternalKeyLength && key_addr.is_initialized()) || + (stored->key_len > kMaxInternalKeyLength && !key_addr.is_initialized())) + return false; + + if (!key_addr.SanityCheckV2()) + return false; + + if (key_addr.is_initialized() && + ((stored->key_len < kMaxBlockSize && key_addr.is_separate_file()) || + (stored->key_len >= kMaxBlockSize && key_addr.is_block_file()))) + return false; + + int num_blocks = NumBlocksForEntry(stored->key_len); + if (entry_.address().num_blocks() != num_blocks) + return false; + + return true; +} + +bool EntryImpl::DataSanityCheck() { + EntryStore* stored = entry_.Data(); + Addr key_addr(stored->long_key); + + // The key must be NULL terminated. + if (!key_addr.is_initialized() && stored->key[stored->key_len]) + return false; + + if (stored->hash != base::Hash(GetKey())) + return false; + + for (int i = 0; i < kNumStreams; i++) { + Addr data_addr(stored->data_addr[i]); + int data_size = stored->data_size[i]; + if (data_size < 0) + return false; + if (!data_size && data_addr.is_initialized()) + return false; + if (!data_addr.SanityCheckV2()) + return false; + if (!data_size) + continue; + if (data_size <= kMaxBlockSize && data_addr.is_separate_file()) + return false; + if (data_size > kMaxBlockSize && data_addr.is_block_file()) + return false; + } + return true; +} + +void EntryImpl::FixForDelete() { + EntryStore* stored = entry_.Data(); + Addr key_addr(stored->long_key); + + if (!key_addr.is_initialized()) + stored->key[stored->key_len] = '\0'; + + for (int i = 0; i < kNumStreams; i++) { + Addr data_addr(stored->data_addr[i]); + int data_size = stored->data_size[i]; + if (data_addr.is_initialized()) { + if ((data_size <= kMaxBlockSize && data_addr.is_separate_file()) || + (data_size > kMaxBlockSize && data_addr.is_block_file()) || + !data_addr.SanityCheckV2()) { + STRESS_NOTREACHED(); + // The address is weird so don't attempt to delete it. + stored->data_addr[i] = 0; + // In general, trust the stored size as it should be in sync with the + // total size tracked by the backend. + } + } + if (data_size < 0) + stored->data_size[i] = 0; + } + entry_.Store(); +} + +void EntryImpl::IncrementIoCount() { + backend_->IncrementIoCount(); +} + +void EntryImpl::DecrementIoCount() { + if (backend_.get()) + backend_->DecrementIoCount(); +} + +void EntryImpl::OnEntryCreated(BackendImpl* backend) { + // Just grab a reference to the backround queue. + background_queue_ = backend->GetBackgroundQueue(); +} + +void EntryImpl::SetTimes(base::Time last_used, base::Time last_modified) { + node_.Data()->last_used = last_used.ToInternalValue(); + node_.Data()->last_modified = last_modified.ToInternalValue(); + node_.set_modified(); +} + +void EntryImpl::ReportIOTime(Operation op, const base::TimeTicks& start) { + if (!backend_.get()) + return; + + switch (op) { + case kRead: + CACHE_UMA(AGE_MS, "ReadTime", 0, start); + break; + case kWrite: + CACHE_UMA(AGE_MS, "WriteTime", 0, start); + break; + case kSparseRead: + CACHE_UMA(AGE_MS, "SparseReadTime", 0, start); + break; + case kSparseWrite: + CACHE_UMA(AGE_MS, "SparseWriteTime", 0, start); + break; + case kAsyncIO: + CACHE_UMA(AGE_MS, "AsyncIOTime", 0, start); + break; + case kReadAsync1: + CACHE_UMA(AGE_MS, "AsyncReadDispatchTime", 0, start); + break; + case kWriteAsync1: + CACHE_UMA(AGE_MS, "AsyncWriteDispatchTime", 0, start); + break; + default: + NOTREACHED(); + } +} + +void EntryImpl::BeginLogging(net::NetLog* net_log, bool created) { + DCHECK(!net_log_.net_log()); + net_log_ = net::BoundNetLog::Make( + net_log, net::NetLog::SOURCE_DISK_CACHE_ENTRY); + net_log_.BeginEvent( + net::NetLog::TYPE_DISK_CACHE_ENTRY_IMPL, + CreateNetLogEntryCreationCallback(this, created)); +} + +const net::BoundNetLog& EntryImpl::net_log() const { + return net_log_; +} + +// static +int EntryImpl::NumBlocksForEntry(int key_size) { + // The longest key that can be stored using one block. + int key1_len = + static_cast<int>(sizeof(EntryStore) - offsetof(EntryStore, key)); + + if (key_size < key1_len || key_size > kMaxInternalKeyLength) + return 1; + + return ((key_size - key1_len) / 256 + 2); +} + +// ------------------------------------------------------------------------ + +void EntryImpl::Doom() { + if (background_queue_.get()) + background_queue_->DoomEntryImpl(this); +} + +void EntryImpl::Close() { + if (background_queue_.get()) + background_queue_->CloseEntryImpl(this); +} + +std::string EntryImpl::GetKey() const { + CacheEntryBlock* entry = const_cast<CacheEntryBlock*>(&entry_); + int key_len = entry->Data()->key_len; + if (key_len <= kMaxInternalKeyLength) + return std::string(entry->Data()->key); + + // We keep a copy of the key so that we can always return it, even if the + // backend is disabled. + if (!key_.empty()) + return key_; + + Addr address(entry->Data()->long_key); + DCHECK(address.is_initialized()); + size_t offset = 0; + if (address.is_block_file()) + offset = address.start_block() * address.BlockSize() + kBlockHeaderSize; + + COMPILE_ASSERT(kNumStreams == kKeyFileIndex, invalid_key_index); + File* key_file = const_cast<EntryImpl*>(this)->GetBackingFile(address, + kKeyFileIndex); + if (!key_file) + return std::string(); + + ++key_len; // We store a trailing \0 on disk that we read back below. + if (!offset && key_file->GetLength() != static_cast<size_t>(key_len)) + return std::string(); + + if (!key_file->Read(WriteInto(&key_, key_len), key_len, offset)) + key_.clear(); + return key_; +} + +Time EntryImpl::GetLastUsed() const { + CacheRankingsBlock* node = const_cast<CacheRankingsBlock*>(&node_); + return Time::FromInternalValue(node->Data()->last_used); +} + +Time EntryImpl::GetLastModified() const { + CacheRankingsBlock* node = const_cast<CacheRankingsBlock*>(&node_); + return Time::FromInternalValue(node->Data()->last_modified); +} + +int32 EntryImpl::GetDataSize(int index) const { + if (index < 0 || index >= kNumStreams) + return 0; + + CacheEntryBlock* entry = const_cast<CacheEntryBlock*>(&entry_); + return entry->Data()->data_size[index]; +} + +int EntryImpl::ReadData(int index, int offset, IOBuffer* buf, int buf_len, + const CompletionCallback& callback) { + if (callback.is_null()) + return ReadDataImpl(index, offset, buf, buf_len, callback); + + DCHECK(node_.Data()->dirty || read_only_); + if (index < 0 || index >= kNumStreams) + return net::ERR_INVALID_ARGUMENT; + + int entry_size = entry_.Data()->data_size[index]; + if (offset >= entry_size || offset < 0 || !buf_len) + return 0; + + if (buf_len < 0) + return net::ERR_INVALID_ARGUMENT; + + if (!background_queue_.get()) + return net::ERR_UNEXPECTED; + + background_queue_->ReadData(this, index, offset, buf, buf_len, callback); + return net::ERR_IO_PENDING; +} + +int EntryImpl::WriteData(int index, int offset, IOBuffer* buf, int buf_len, + const CompletionCallback& callback, bool truncate) { + if (callback.is_null()) + return WriteDataImpl(index, offset, buf, buf_len, callback, truncate); + + DCHECK(node_.Data()->dirty || read_only_); + if (index < 0 || index >= kNumStreams) + return net::ERR_INVALID_ARGUMENT; + + if (offset < 0 || buf_len < 0) + return net::ERR_INVALID_ARGUMENT; + + if (!background_queue_.get()) + return net::ERR_UNEXPECTED; + + background_queue_->WriteData(this, index, offset, buf, buf_len, truncate, + callback); + return net::ERR_IO_PENDING; +} + +int EntryImpl::ReadSparseData(int64 offset, IOBuffer* buf, int buf_len, + const CompletionCallback& callback) { + if (callback.is_null()) + return ReadSparseDataImpl(offset, buf, buf_len, callback); + + if (!background_queue_.get()) + return net::ERR_UNEXPECTED; + + background_queue_->ReadSparseData(this, offset, buf, buf_len, callback); + return net::ERR_IO_PENDING; +} + +int EntryImpl::WriteSparseData(int64 offset, IOBuffer* buf, int buf_len, + const CompletionCallback& callback) { + if (callback.is_null()) + return WriteSparseDataImpl(offset, buf, buf_len, callback); + + if (!background_queue_.get()) + return net::ERR_UNEXPECTED; + + background_queue_->WriteSparseData(this, offset, buf, buf_len, callback); + return net::ERR_IO_PENDING; +} + +int EntryImpl::GetAvailableRange(int64 offset, int len, int64* start, + const CompletionCallback& callback) { + if (!background_queue_.get()) + return net::ERR_UNEXPECTED; + + background_queue_->GetAvailableRange(this, offset, len, start, callback); + return net::ERR_IO_PENDING; +} + +bool EntryImpl::CouldBeSparse() const { + if (sparse_.get()) + return true; + + scoped_ptr<SparseControl> sparse; + sparse.reset(new SparseControl(const_cast<EntryImpl*>(this))); + return sparse->CouldBeSparse(); +} + +void EntryImpl::CancelSparseIO() { + if (background_queue_.get()) + background_queue_->CancelSparseIO(this); +} + +int EntryImpl::ReadyForSparseIO(const CompletionCallback& callback) { + if (!sparse_.get()) + return net::OK; + + if (!background_queue_.get()) + return net::ERR_UNEXPECTED; + + background_queue_->ReadyForSparseIO(this, callback); + return net::ERR_IO_PENDING; +} + +// When an entry is deleted from the cache, we clean up all the data associated +// with it for two reasons: to simplify the reuse of the block (we know that any +// unused block is filled with zeros), and to simplify the handling of write / +// read partial information from an entry (don't have to worry about returning +// data related to a previous cache entry because the range was not fully +// written before). +EntryImpl::~EntryImpl() { + if (!backend_.get()) { + entry_.clear_modified(); + node_.clear_modified(); + return; + } + Log("~EntryImpl in"); + + // Save the sparse info to disk. This will generate IO for this entry and + // maybe for a child entry, so it is important to do it before deleting this + // entry. + sparse_.reset(); + + // Remove this entry from the list of open entries. + backend_->OnEntryDestroyBegin(entry_.address()); + + if (doomed_) { + DeleteEntryData(true); + } else { +#if defined(NET_BUILD_STRESS_CACHE) + SanityCheck(); +#endif + net_log_.AddEvent(net::NetLog::TYPE_ENTRY_CLOSE); + bool ret = true; + for (int index = 0; index < kNumStreams; index++) { + if (user_buffers_[index].get()) { + if (!(ret = Flush(index, 0))) + LOG(ERROR) << "Failed to save user data"; + } + if (unreported_size_[index]) { + backend_->ModifyStorageSize( + entry_.Data()->data_size[index] - unreported_size_[index], + entry_.Data()->data_size[index]); + } + } + + if (!ret) { + // There was a failure writing the actual data. Mark the entry as dirty. + int current_id = backend_->GetCurrentEntryId(); + node_.Data()->dirty = current_id == 1 ? -1 : current_id - 1; + node_.Store(); + } else if (node_.HasData() && !dirty_ && node_.Data()->dirty) { + node_.Data()->dirty = 0; + node_.Store(); + } + } + + Trace("~EntryImpl out 0x%p", reinterpret_cast<void*>(this)); + net_log_.EndEvent(net::NetLog::TYPE_DISK_CACHE_ENTRY_IMPL); + backend_->OnEntryDestroyEnd(); +} + +// ------------------------------------------------------------------------ + +int EntryImpl::InternalReadData(int index, int offset, + IOBuffer* buf, int buf_len, + const CompletionCallback& callback) { + DCHECK(node_.Data()->dirty || read_only_); + DVLOG(2) << "Read from " << index << " at " << offset << " : " << buf_len; + if (index < 0 || index >= kNumStreams) + return net::ERR_INVALID_ARGUMENT; + + int entry_size = entry_.Data()->data_size[index]; + if (offset >= entry_size || offset < 0 || !buf_len) + return 0; + + if (buf_len < 0) + return net::ERR_INVALID_ARGUMENT; + + if (!backend_.get()) + return net::ERR_UNEXPECTED; + + TimeTicks start = TimeTicks::Now(); + + if (offset + buf_len > entry_size) + buf_len = entry_size - offset; + + UpdateRank(false); + + backend_->OnEvent(Stats::READ_DATA); + backend_->OnRead(buf_len); + + Addr address(entry_.Data()->data_addr[index]); + int eof = address.is_initialized() ? entry_size : 0; + if (user_buffers_[index].get() && + user_buffers_[index]->PreRead(eof, offset, &buf_len)) { + // Complete the operation locally. + buf_len = user_buffers_[index]->Read(offset, buf, buf_len); + ReportIOTime(kRead, start); + return buf_len; + } + + address.set_value(entry_.Data()->data_addr[index]); + DCHECK(address.is_initialized()); + if (!address.is_initialized()) { + DoomImpl(); + return net::ERR_FAILED; + } + + File* file = GetBackingFile(address, index); + if (!file) { + DoomImpl(); + LOG(ERROR) << "No file for " << std::hex << address.value(); + return net::ERR_FILE_NOT_FOUND; + } + + size_t file_offset = offset; + if (address.is_block_file()) { + DCHECK_LE(offset + buf_len, kMaxBlockSize); + file_offset += address.start_block() * address.BlockSize() + + kBlockHeaderSize; + } + + SyncCallback* io_callback = NULL; + if (!callback.is_null()) { + io_callback = new SyncCallback(this, buf, callback, + net::NetLog::TYPE_ENTRY_READ_DATA); + } + + TimeTicks start_async = TimeTicks::Now(); + + bool completed; + if (!file->Read(buf->data(), buf_len, file_offset, io_callback, &completed)) { + if (io_callback) + io_callback->Discard(); + DoomImpl(); + return net::ERR_CACHE_READ_FAILURE; + } + + if (io_callback && completed) + io_callback->Discard(); + + if (io_callback) + ReportIOTime(kReadAsync1, start_async); + + ReportIOTime(kRead, start); + return (completed || callback.is_null()) ? buf_len : net::ERR_IO_PENDING; +} + +int EntryImpl::InternalWriteData(int index, int offset, + IOBuffer* buf, int buf_len, + const CompletionCallback& callback, + bool truncate) { + DCHECK(node_.Data()->dirty || read_only_); + DVLOG(2) << "Write to " << index << " at " << offset << " : " << buf_len; + if (index < 0 || index >= kNumStreams) + return net::ERR_INVALID_ARGUMENT; + + if (offset < 0 || buf_len < 0) + return net::ERR_INVALID_ARGUMENT; + + if (!backend_.get()) + return net::ERR_UNEXPECTED; + + int max_file_size = backend_->MaxFileSize(); + + // offset or buf_len could be negative numbers. + if (offset > max_file_size || buf_len > max_file_size || + offset + buf_len > max_file_size) { + int size = offset + buf_len; + if (size <= max_file_size) + size = kint32max; + backend_->TooMuchStorageRequested(size); + return net::ERR_FAILED; + } + + TimeTicks start = TimeTicks::Now(); + + // Read the size at this point (it may change inside prepare). + int entry_size = entry_.Data()->data_size[index]; + bool extending = entry_size < offset + buf_len; + truncate = truncate && entry_size > offset + buf_len; + Trace("To PrepareTarget 0x%x", entry_.address().value()); + if (!PrepareTarget(index, offset, buf_len, truncate)) + return net::ERR_FAILED; + + Trace("From PrepareTarget 0x%x", entry_.address().value()); + if (extending || truncate) + UpdateSize(index, entry_size, offset + buf_len); + + UpdateRank(true); + + backend_->OnEvent(Stats::WRITE_DATA); + backend_->OnWrite(buf_len); + + if (user_buffers_[index].get()) { + // Complete the operation locally. + user_buffers_[index]->Write(offset, buf, buf_len); + ReportIOTime(kWrite, start); + return buf_len; + } + + Addr address(entry_.Data()->data_addr[index]); + if (offset + buf_len == 0) { + if (truncate) { + DCHECK(!address.is_initialized()); + } + return 0; + } + + File* file = GetBackingFile(address, index); + if (!file) + return net::ERR_FILE_NOT_FOUND; + + size_t file_offset = offset; + if (address.is_block_file()) { + DCHECK_LE(offset + buf_len, kMaxBlockSize); + file_offset += address.start_block() * address.BlockSize() + + kBlockHeaderSize; + } else if (truncate || (extending && !buf_len)) { + if (!file->SetLength(offset + buf_len)) + return net::ERR_FAILED; + } + + if (!buf_len) + return 0; + + SyncCallback* io_callback = NULL; + if (!callback.is_null()) { + io_callback = new SyncCallback(this, buf, callback, + net::NetLog::TYPE_ENTRY_WRITE_DATA); + } + + TimeTicks start_async = TimeTicks::Now(); + + bool completed; + if (!file->Write(buf->data(), buf_len, file_offset, io_callback, + &completed)) { + if (io_callback) + io_callback->Discard(); + return net::ERR_CACHE_WRITE_FAILURE; + } + + if (io_callback && completed) + io_callback->Discard(); + + if (io_callback) + ReportIOTime(kWriteAsync1, start_async); + + ReportIOTime(kWrite, start); + return (completed || callback.is_null()) ? buf_len : net::ERR_IO_PENDING; +} + +// ------------------------------------------------------------------------ + +bool EntryImpl::CreateDataBlock(int index, int size) { + DCHECK(index >= 0 && index < kNumStreams); + + Addr address(entry_.Data()->data_addr[index]); + if (!CreateBlock(size, &address)) + return false; + + entry_.Data()->data_addr[index] = address.value(); + entry_.Store(); + return true; +} + +bool EntryImpl::CreateBlock(int size, Addr* address) { + DCHECK(!address->is_initialized()); + if (!backend_.get()) + return false; + + FileType file_type = Addr::RequiredFileType(size); + if (EXTERNAL == file_type) { + if (size > backend_->MaxFileSize()) + return false; + if (!backend_->CreateExternalFile(address)) + return false; + } else { + int num_blocks = Addr::RequiredBlocks(size, file_type); + + if (!backend_->CreateBlock(file_type, num_blocks, address)) + return false; + } + return true; +} + +// Note that this method may end up modifying a block file so upon return the +// involved block will be free, and could be reused for something else. If there +// is a crash after that point (and maybe before returning to the caller), the +// entry will be left dirty... and at some point it will be discarded; it is +// important that the entry doesn't keep a reference to this address, or we'll +// end up deleting the contents of |address| once again. +void EntryImpl::DeleteData(Addr address, int index) { + DCHECK(backend_.get()); + if (!address.is_initialized()) + return; + if (address.is_separate_file()) { + int failure = !DeleteCacheFile(backend_->GetFileName(address)); + CACHE_UMA(COUNTS, "DeleteFailed", 0, failure); + if (failure) { + LOG(ERROR) << "Failed to delete " << + backend_->GetFileName(address).value() << " from the cache."; + } + if (files_[index].get()) + files_[index] = NULL; // Releases the object. + } else { + backend_->DeleteBlock(address, true); + } +} + +void EntryImpl::UpdateRank(bool modified) { + if (!backend_.get()) + return; + + if (!doomed_) { + // Everything is handled by the backend. + backend_->UpdateRank(this, modified); + return; + } + + Time current = Time::Now(); + node_.Data()->last_used = current.ToInternalValue(); + + if (modified) + node_.Data()->last_modified = current.ToInternalValue(); +} + +File* EntryImpl::GetBackingFile(Addr address, int index) { + if (!backend_.get()) + return NULL; + + File* file; + if (address.is_separate_file()) + file = GetExternalFile(address, index); + else + file = backend_->File(address); + return file; +} + +File* EntryImpl::GetExternalFile(Addr address, int index) { + DCHECK(index >= 0 && index <= kKeyFileIndex); + if (!files_[index].get()) { + // For a key file, use mixed mode IO. + scoped_refptr<File> file(new File(kKeyFileIndex == index)); + if (file->Init(backend_->GetFileName(address))) + files_[index].swap(file); + } + return files_[index].get(); +} + +// We keep a memory buffer for everything that ends up stored on a block file +// (because we don't know yet the final data size), and for some of the data +// that end up on external files. This function will initialize that memory +// buffer and / or the files needed to store the data. +// +// In general, a buffer may overlap data already stored on disk, and in that +// case, the contents of the buffer are the most accurate. It may also extend +// the file, but we don't want to read from disk just to keep the buffer up to +// date. This means that as soon as there is a chance to get confused about what +// is the most recent version of some part of a file, we'll flush the buffer and +// reuse it for the new data. Keep in mind that the normal use pattern is quite +// simple (write sequentially from the beginning), so we optimize for handling +// that case. +bool EntryImpl::PrepareTarget(int index, int offset, int buf_len, + bool truncate) { + if (truncate) + return HandleTruncation(index, offset, buf_len); + + if (!offset && !buf_len) + return true; + + Addr address(entry_.Data()->data_addr[index]); + if (address.is_initialized()) { + if (address.is_block_file() && !MoveToLocalBuffer(index)) + return false; + + if (!user_buffers_[index].get() && offset < kMaxBlockSize) { + // We are about to create a buffer for the first 16KB, make sure that we + // preserve existing data. + if (!CopyToLocalBuffer(index)) + return false; + } + } + + if (!user_buffers_[index].get()) + user_buffers_[index].reset(new UserBuffer(backend_.get())); + + return PrepareBuffer(index, offset, buf_len); +} + +// We get to this function with some data already stored. If there is a +// truncation that results on data stored internally, we'll explicitly +// handle the case here. +bool EntryImpl::HandleTruncation(int index, int offset, int buf_len) { + Addr address(entry_.Data()->data_addr[index]); + + int current_size = entry_.Data()->data_size[index]; + int new_size = offset + buf_len; + + if (!new_size) { + // This is by far the most common scenario. + backend_->ModifyStorageSize(current_size - unreported_size_[index], 0); + entry_.Data()->data_addr[index] = 0; + entry_.Data()->data_size[index] = 0; + unreported_size_[index] = 0; + entry_.Store(); + DeleteData(address, index); + + user_buffers_[index].reset(); + return true; + } + + // We never postpone truncating a file, if there is one, but we may postpone + // telling the backend about the size reduction. + if (user_buffers_[index].get()) { + DCHECK_GE(current_size, user_buffers_[index]->Start()); + if (!address.is_initialized()) { + // There is no overlap between the buffer and disk. + if (new_size > user_buffers_[index]->Start()) { + // Just truncate our buffer. + DCHECK_LT(new_size, user_buffers_[index]->End()); + user_buffers_[index]->Truncate(new_size); + return true; + } + + // Just discard our buffer. + user_buffers_[index]->Reset(); + return PrepareBuffer(index, offset, buf_len); + } + + // There is some overlap or we need to extend the file before the + // truncation. + if (offset > user_buffers_[index]->Start()) + user_buffers_[index]->Truncate(new_size); + UpdateSize(index, current_size, new_size); + if (!Flush(index, 0)) + return false; + user_buffers_[index].reset(); + } + + // We have data somewhere, and it is not in a buffer. + DCHECK(!user_buffers_[index].get()); + DCHECK(address.is_initialized()); + + if (new_size > kMaxBlockSize) + return true; // Let the operation go directly to disk. + + return ImportSeparateFile(index, offset + buf_len); +} + +bool EntryImpl::CopyToLocalBuffer(int index) { + Addr address(entry_.Data()->data_addr[index]); + DCHECK(!user_buffers_[index].get()); + DCHECK(address.is_initialized()); + + int len = std::min(entry_.Data()->data_size[index], kMaxBlockSize); + user_buffers_[index].reset(new UserBuffer(backend_.get())); + user_buffers_[index]->Write(len, NULL, 0); + + File* file = GetBackingFile(address, index); + int offset = 0; + + if (address.is_block_file()) + offset = address.start_block() * address.BlockSize() + kBlockHeaderSize; + + if (!file || + !file->Read(user_buffers_[index]->Data(), len, offset, NULL, NULL)) { + user_buffers_[index].reset(); + return false; + } + return true; +} + +bool EntryImpl::MoveToLocalBuffer(int index) { + if (!CopyToLocalBuffer(index)) + return false; + + Addr address(entry_.Data()->data_addr[index]); + entry_.Data()->data_addr[index] = 0; + entry_.Store(); + DeleteData(address, index); + + // If we lose this entry we'll see it as zero sized. + int len = entry_.Data()->data_size[index]; + backend_->ModifyStorageSize(len - unreported_size_[index], 0); + unreported_size_[index] = len; + return true; +} + +bool EntryImpl::ImportSeparateFile(int index, int new_size) { + if (entry_.Data()->data_size[index] > new_size) + UpdateSize(index, entry_.Data()->data_size[index], new_size); + + return MoveToLocalBuffer(index); +} + +bool EntryImpl::PrepareBuffer(int index, int offset, int buf_len) { + DCHECK(user_buffers_[index].get()); + if ((user_buffers_[index]->End() && offset > user_buffers_[index]->End()) || + offset > entry_.Data()->data_size[index]) { + // We are about to extend the buffer or the file (with zeros), so make sure + // that we are not overwriting anything. + Addr address(entry_.Data()->data_addr[index]); + if (address.is_initialized() && address.is_separate_file()) { + if (!Flush(index, 0)) + return false; + // There is an actual file already, and we don't want to keep track of + // its length so we let this operation go straight to disk. + // The only case when a buffer is allowed to extend the file (as in fill + // with zeros before the start) is when there is no file yet to extend. + user_buffers_[index].reset(); + return true; + } + } + + if (!user_buffers_[index]->PreWrite(offset, buf_len)) { + if (!Flush(index, offset + buf_len)) + return false; + + // Lets try again. + if (offset > user_buffers_[index]->End() || + !user_buffers_[index]->PreWrite(offset, buf_len)) { + // We cannot complete the operation with a buffer. + DCHECK(!user_buffers_[index]->Size()); + DCHECK(!user_buffers_[index]->Start()); + user_buffers_[index].reset(); + } + } + return true; +} + +bool EntryImpl::Flush(int index, int min_len) { + Addr address(entry_.Data()->data_addr[index]); + DCHECK(user_buffers_[index].get()); + DCHECK(!address.is_initialized() || address.is_separate_file()); + DVLOG(3) << "Flush"; + + int size = std::max(entry_.Data()->data_size[index], min_len); + if (size && !address.is_initialized() && !CreateDataBlock(index, size)) + return false; + + if (!entry_.Data()->data_size[index]) { + DCHECK(!user_buffers_[index]->Size()); + return true; + } + + address.set_value(entry_.Data()->data_addr[index]); + + int len = user_buffers_[index]->Size(); + int offset = user_buffers_[index]->Start(); + if (!len && !offset) + return true; + + if (address.is_block_file()) { + DCHECK_EQ(len, entry_.Data()->data_size[index]); + DCHECK(!offset); + offset = address.start_block() * address.BlockSize() + kBlockHeaderSize; + } + + File* file = GetBackingFile(address, index); + if (!file) + return false; + + if (!file->Write(user_buffers_[index]->Data(), len, offset, NULL, NULL)) + return false; + user_buffers_[index]->Reset(); + + return true; +} + +void EntryImpl::UpdateSize(int index, int old_size, int new_size) { + if (entry_.Data()->data_size[index] == new_size) + return; + + unreported_size_[index] += new_size - old_size; + entry_.Data()->data_size[index] = new_size; + entry_.set_modified(); +} + +int EntryImpl::InitSparseData() { + if (sparse_.get()) + return net::OK; + + // Use a local variable so that sparse_ never goes from 'valid' to NULL. + scoped_ptr<SparseControl> sparse(new SparseControl(this)); + int result = sparse->Init(); + if (net::OK == result) + sparse_.swap(sparse); + + return result; +} + +void EntryImpl::SetEntryFlags(uint32 flags) { + entry_.Data()->flags |= flags; + entry_.set_modified(); +} + +uint32 EntryImpl::GetEntryFlags() { + return entry_.Data()->flags; +} + +void EntryImpl::GetData(int index, char** buffer, Addr* address) { + DCHECK(backend_.get()); + if (user_buffers_[index].get() && user_buffers_[index]->Size() && + !user_buffers_[index]->Start()) { + // The data is already in memory, just copy it and we're done. + int data_len = entry_.Data()->data_size[index]; + if (data_len <= user_buffers_[index]->Size()) { + DCHECK(!user_buffers_[index]->Start()); + *buffer = new char[data_len]; + memcpy(*buffer, user_buffers_[index]->Data(), data_len); + return; + } + } + + // Bad news: we'd have to read the info from disk so instead we'll just tell + // the caller where to read from. + *buffer = NULL; + address->set_value(entry_.Data()->data_addr[index]); + if (address->is_initialized()) { + // Prevent us from deleting the block from the backing store. + backend_->ModifyStorageSize(entry_.Data()->data_size[index] - + unreported_size_[index], 0); + entry_.Data()->data_addr[index] = 0; + entry_.Data()->data_size[index] = 0; + } +} + +void EntryImpl::Log(const char* msg) { + int dirty = 0; + if (node_.HasData()) { + dirty = node_.Data()->dirty; + } + + Trace("%s 0x%p 0x%x 0x%x", msg, reinterpret_cast<void*>(this), + entry_.address().value(), node_.address().value()); + + Trace(" data: 0x%x 0x%x 0x%x", entry_.Data()->data_addr[0], + entry_.Data()->data_addr[1], entry_.Data()->long_key); + + Trace(" doomed: %d 0x%x", doomed_, dirty); +} + +} // namespace disk_cache |