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, 0 insertions, 1550 deletions
diff --git a/chromium/net/disk_cache/entry_impl.cc b/chromium/net/disk_cache/entry_impl.cc deleted file mode 100644 index 4b6e4cf2b04..00000000000 --- a/chromium/net/disk_cache/entry_impl.cc +++ /dev/null @@ -1,1550 +0,0 @@ -// 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 |