This source file includes following definitions.
- GenerateChildName
- signature_
- OnFileIOComplete
- Start
- ReadData
- DeleteChildren
- GetSparseEventType
- LogChildOperationEnd
- result_
- CouldBeSparse
- StartIO
- GetAvailableRange
- CancelIO
- ReadyToUse
- DeleteChildren
- Init
- CreateSparseEntry
- OpenSparseEntry
- OpenChild
- CloseChild
- ContinueWithoutChild
- WriteSparseData
- DoChildIO
- DoChildIOCompleted
- GenerateChildKey
- KillChildAndContinue
- ChildPresent
- SetChildBit
- VerifyRange
- UpdateRange
- PartialBlockLength
- InitChildData
- DoGetAvailableRange
- DoUserCallback
- DoAbortCallbacks
- OnChildIOCompleted
#include "net/disk_cache/blockfile/sparse_control.h"
#include "base/bind.h"
#include "base/format_macros.h"
#include "base/logging.h"
#include "base/message_loop/message_loop.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/time/time.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h"
#include "net/disk_cache/blockfile/backend_impl.h"
#include "net/disk_cache/blockfile/entry_impl.h"
#include "net/disk_cache/blockfile/file.h"
#include "net/disk_cache/net_log_parameters.h"
using base::Time;
namespace {
const int kSparseIndex = 2;
const int kSparseData = 1;
const int kMaxMapSize = 8 * 1024;
const int kMaxEntrySize = 0x100000;
const int kBlockSize = 1024;
std::string GenerateChildName(const std::string& base_name, int64 signature,
int64 child_id) {
return base::StringPrintf("Range_%s:%" PRIx64 ":%" PRIx64, base_name.c_str(),
signature, child_id);
}
class ChildrenDeleter
: public base::RefCounted<ChildrenDeleter>,
public disk_cache::FileIOCallback {
public:
ChildrenDeleter(disk_cache::BackendImpl* backend, const std::string& name)
: backend_(backend->GetWeakPtr()), name_(name), signature_(0) {}
virtual void OnFileIOComplete(int bytes_copied) OVERRIDE;
void Start(char* buffer, int len);
void ReadData(disk_cache::Addr address, int len);
private:
friend class base::RefCounted<ChildrenDeleter>;
virtual ~ChildrenDeleter() {}
void DeleteChildren();
base::WeakPtr<disk_cache::BackendImpl> backend_;
std::string name_;
disk_cache::Bitmap children_map_;
int64 signature_;
scoped_ptr<char[]> buffer_;
DISALLOW_COPY_AND_ASSIGN(ChildrenDeleter);
};
void ChildrenDeleter::OnFileIOComplete(int bytes_copied) {
char* buffer = buffer_.release();
Start(buffer, bytes_copied);
}
void ChildrenDeleter::Start(char* buffer, int len) {
buffer_.reset(buffer);
if (len < static_cast<int>(sizeof(disk_cache::SparseData)))
return Release();
disk_cache::SparseData* data =
reinterpret_cast<disk_cache::SparseData*>(buffer);
signature_ = data->header.signature;
int num_bits = (len - sizeof(disk_cache::SparseHeader)) * 8;
children_map_.Resize(num_bits, false);
children_map_.SetMap(data->bitmap, num_bits / 32);
buffer_.reset();
DeleteChildren();
}
void ChildrenDeleter::ReadData(disk_cache::Addr address, int len) {
DCHECK(address.is_block_file());
if (!backend_)
return Release();
disk_cache::File* file(backend_->File(address));
if (!file)
return Release();
size_t file_offset = address.start_block() * address.BlockSize() +
disk_cache::kBlockHeaderSize;
buffer_.reset(new char[len]);
bool completed;
if (!file->Read(buffer_.get(), len, file_offset, this, &completed))
return Release();
if (completed)
OnFileIOComplete(len);
}
void ChildrenDeleter::DeleteChildren() {
int child_id = 0;
if (!children_map_.FindNextSetBit(&child_id) || !backend_) {
return Release();
}
std::string child_name = GenerateChildName(name_, signature_, child_id);
backend_->SyncDoomEntry(child_name);
children_map_.Set(child_id, false);
base::MessageLoop::current()->PostTask(
FROM_HERE, base::Bind(&ChildrenDeleter::DeleteChildren, this));
}
net::NetLog::EventType GetSparseEventType(
disk_cache::SparseControl::SparseOperation operation) {
switch (operation) {
case disk_cache::SparseControl::kReadOperation:
return net::NetLog::TYPE_SPARSE_READ;
case disk_cache::SparseControl::kWriteOperation:
return net::NetLog::TYPE_SPARSE_WRITE;
case disk_cache::SparseControl::kGetRangeOperation:
return net::NetLog::TYPE_SPARSE_GET_RANGE;
default:
NOTREACHED();
return net::NetLog::TYPE_CANCELLED;
}
}
void LogChildOperationEnd(const net::BoundNetLog& net_log,
disk_cache::SparseControl::SparseOperation operation,
int result) {
if (net_log.IsLogging()) {
net::NetLog::EventType event_type;
switch (operation) {
case disk_cache::SparseControl::kReadOperation:
event_type = net::NetLog::TYPE_SPARSE_READ_CHILD_DATA;
break;
case disk_cache::SparseControl::kWriteOperation:
event_type = net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA;
break;
case disk_cache::SparseControl::kGetRangeOperation:
return;
default:
NOTREACHED();
return;
}
net_log.EndEventWithNetErrorCode(event_type, result);
}
}
}
namespace disk_cache {
SparseControl::SparseControl(EntryImpl* entry)
: entry_(entry),
child_(NULL),
operation_(kNoOperation),
pending_(false),
finished_(false),
init_(false),
range_found_(false),
abort_(false),
child_map_(child_data_.bitmap, kNumSparseBits, kNumSparseBits / 32),
offset_(0),
buf_len_(0),
child_offset_(0),
child_len_(0),
result_(0) {
memset(&sparse_header_, 0, sizeof(sparse_header_));
memset(&child_data_, 0, sizeof(child_data_));
}
SparseControl::~SparseControl() {
if (child_)
CloseChild();
if (init_)
WriteSparseData();
}
bool SparseControl::CouldBeSparse() const {
DCHECK(!init_);
if (entry_->GetDataSize(kSparseData))
return false;
return (entry_->GetDataSize(kSparseIndex) != 0);
}
int SparseControl::StartIO(SparseOperation op, int64 offset, net::IOBuffer* buf,
int buf_len, const CompletionCallback& callback) {
DCHECK(init_);
if (operation_ != kNoOperation)
return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
if (offset < 0 || buf_len < 0)
return net::ERR_INVALID_ARGUMENT;
if (offset + buf_len >= 0x1000000000LL || offset + buf_len < 0)
return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
DCHECK(!user_buf_);
DCHECK(user_callback_.is_null());
if (!buf && (op == kReadOperation || op == kWriteOperation))
return 0;
operation_ = op;
offset_ = offset;
user_buf_ = buf ? new net::DrainableIOBuffer(buf, buf_len) : NULL;
buf_len_ = buf_len;
user_callback_ = callback;
result_ = 0;
pending_ = false;
finished_ = false;
abort_ = false;
if (entry_->net_log().IsLogging()) {
entry_->net_log().BeginEvent(
GetSparseEventType(operation_),
CreateNetLogSparseOperationCallback(offset_, buf_len_));
}
DoChildrenIO();
if (!pending_) {
operation_ = kNoOperation;
user_buf_ = NULL;
user_callback_.Reset();
return result_;
}
return net::ERR_IO_PENDING;
}
int SparseControl::GetAvailableRange(int64 offset, int len, int64* start) {
DCHECK(init_);
if (operation_ != kNoOperation)
return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
DCHECK(start);
range_found_ = false;
int result = StartIO(
kGetRangeOperation, offset, NULL, len, CompletionCallback());
if (range_found_) {
*start = offset_;
return result;
}
*start = offset;
return result < 0 ? result : 0;
}
void SparseControl::CancelIO() {
if (operation_ == kNoOperation)
return;
abort_ = true;
}
int SparseControl::ReadyToUse(const CompletionCallback& callback) {
if (!abort_)
return net::OK;
entry_->AddRef();
abort_callbacks_.push_back(callback);
return net::ERR_IO_PENDING;
}
void SparseControl::DeleteChildren(EntryImpl* entry) {
DCHECK(entry->GetEntryFlags() & PARENT_ENTRY);
int data_len = entry->GetDataSize(kSparseIndex);
if (data_len < static_cast<int>(sizeof(SparseData)) ||
entry->GetDataSize(kSparseData))
return;
int map_len = data_len - sizeof(SparseHeader);
if (map_len > kMaxMapSize || map_len % 4)
return;
char* buffer;
Addr address;
entry->GetData(kSparseIndex, &buffer, &address);
if (!buffer && !address.is_initialized())
return;
entry->net_log().AddEvent(net::NetLog::TYPE_SPARSE_DELETE_CHILDREN);
DCHECK(entry->backend_);
ChildrenDeleter* deleter = new ChildrenDeleter(entry->backend_.get(),
entry->GetKey());
deleter->AddRef();
if (buffer) {
base::MessageLoop::current()->PostTask(
FROM_HERE,
base::Bind(&ChildrenDeleter::Start, deleter, buffer, data_len));
} else {
base::MessageLoop::current()->PostTask(
FROM_HERE,
base::Bind(&ChildrenDeleter::ReadData, deleter, address, data_len));
}
}
int SparseControl::Init() {
DCHECK(!init_);
if (entry_->GetDataSize(kSparseData))
return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
int rv = net::OK;
int data_len = entry_->GetDataSize(kSparseIndex);
if (!data_len) {
rv = CreateSparseEntry();
} else {
rv = OpenSparseEntry(data_len);
}
if (rv == net::OK)
init_ = true;
return rv;
}
int SparseControl::CreateSparseEntry() {
if (CHILD_ENTRY & entry_->GetEntryFlags())
return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
memset(&sparse_header_, 0, sizeof(sparse_header_));
sparse_header_.signature = Time::Now().ToInternalValue();
sparse_header_.magic = kIndexMagic;
sparse_header_.parent_key_len = entry_->GetKey().size();
children_map_.Resize(kNumSparseBits, true);
scoped_refptr<net::IOBuffer> buf(
new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_)));
int rv = entry_->WriteData(kSparseIndex, 0, buf.get(), sizeof(sparse_header_),
CompletionCallback(), false);
if (rv != sizeof(sparse_header_)) {
DLOG(ERROR) << "Unable to save sparse_header_";
return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
}
entry_->SetEntryFlags(PARENT_ENTRY);
return net::OK;
}
int SparseControl::OpenSparseEntry(int data_len) {
if (data_len < static_cast<int>(sizeof(SparseData)))
return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
if (entry_->GetDataSize(kSparseData))
return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
if (!(PARENT_ENTRY & entry_->GetEntryFlags()))
return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
int map_len = data_len - sizeof(sparse_header_);
if (map_len > kMaxMapSize || map_len % 4)
return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
scoped_refptr<net::IOBuffer> buf(
new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_)));
int rv = entry_->ReadData(kSparseIndex, 0, buf.get(), sizeof(sparse_header_),
CompletionCallback());
if (rv != static_cast<int>(sizeof(sparse_header_)))
return net::ERR_CACHE_READ_FAILURE;
if (sparse_header_.magic != kIndexMagic ||
sparse_header_.parent_key_len !=
static_cast<int>(entry_->GetKey().size()))
return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
buf = new net::IOBuffer(map_len);
rv = entry_->ReadData(kSparseIndex, sizeof(sparse_header_), buf.get(),
map_len, CompletionCallback());
if (rv != map_len)
return net::ERR_CACHE_READ_FAILURE;
children_map_.Resize(map_len * 8, false);
children_map_.SetMap(reinterpret_cast<uint32*>(buf->data()), map_len);
return net::OK;
}
bool SparseControl::OpenChild() {
DCHECK_GE(result_, 0);
std::string key = GenerateChildKey();
if (child_) {
if (key == child_->GetKey())
return true;
CloseChild();
}
if (!ChildPresent())
return ContinueWithoutChild(key);
if (!entry_->backend_)
return false;
child_ = entry_->backend_->OpenEntryImpl(key);
if (!child_)
return ContinueWithoutChild(key);
EntryImpl* child = static_cast<EntryImpl*>(child_);
if (!(CHILD_ENTRY & child->GetEntryFlags()) ||
child->GetDataSize(kSparseIndex) <
static_cast<int>(sizeof(child_data_)))
return KillChildAndContinue(key, false);
scoped_refptr<net::WrappedIOBuffer> buf(
new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
int rv = child_->ReadData(kSparseIndex, 0, buf.get(), sizeof(child_data_),
CompletionCallback());
if (rv != sizeof(child_data_))
return KillChildAndContinue(key, true);
if (child_data_.header.signature != sparse_header_.signature ||
child_data_.header.magic != kIndexMagic)
return KillChildAndContinue(key, false);
if (child_data_.header.last_block_len < 0 ||
child_data_.header.last_block_len > kBlockSize) {
child_data_.header.last_block_len = 0;
child_data_.header.last_block = -1;
}
return true;
}
void SparseControl::CloseChild() {
scoped_refptr<net::WrappedIOBuffer> buf(
new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
int rv = child_->WriteData(kSparseIndex, 0, buf.get(), sizeof(child_data_),
CompletionCallback(),
false);
if (rv != sizeof(child_data_))
DLOG(ERROR) << "Failed to save child data";
child_->Release();
child_ = NULL;
}
bool SparseControl::ContinueWithoutChild(const std::string& key) {
if (kReadOperation == operation_)
return false;
if (kGetRangeOperation == operation_)
return true;
if (!entry_->backend_)
return false;
child_ = entry_->backend_->CreateEntryImpl(key);
if (!child_) {
child_ = NULL;
result_ = net::ERR_CACHE_READ_FAILURE;
return false;
}
InitChildData();
return true;
}
void SparseControl::WriteSparseData() {
scoped_refptr<net::IOBuffer> buf(new net::WrappedIOBuffer(
reinterpret_cast<const char*>(children_map_.GetMap())));
int len = children_map_.ArraySize() * 4;
int rv = entry_->WriteData(kSparseIndex, sizeof(sparse_header_), buf.get(),
len, CompletionCallback(), false);
if (rv != len) {
DLOG(ERROR) << "Unable to save sparse map";
}
}
bool SparseControl::DoChildIO() {
finished_ = true;
if (!buf_len_ || result_ < 0)
return false;
if (!OpenChild())
return false;
if (!VerifyRange())
return false;
finished_ = false;
CompletionCallback callback;
if (!user_callback_.is_null()) {
callback =
base::Bind(&SparseControl::OnChildIOCompleted, base::Unretained(this));
}
int rv = 0;
switch (operation_) {
case kReadOperation:
if (entry_->net_log().IsLogging()) {
entry_->net_log().BeginEvent(
net::NetLog::TYPE_SPARSE_READ_CHILD_DATA,
CreateNetLogSparseReadWriteCallback(child_->net_log().source(),
child_len_));
}
rv = child_->ReadDataImpl(kSparseData, child_offset_, user_buf_.get(),
child_len_, callback);
break;
case kWriteOperation:
if (entry_->net_log().IsLogging()) {
entry_->net_log().BeginEvent(
net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA,
CreateNetLogSparseReadWriteCallback(child_->net_log().source(),
child_len_));
}
rv = child_->WriteDataImpl(kSparseData, child_offset_, user_buf_.get(),
child_len_, callback, false);
break;
case kGetRangeOperation:
rv = DoGetAvailableRange();
break;
default:
NOTREACHED();
}
if (rv == net::ERR_IO_PENDING) {
if (!pending_) {
pending_ = true;
entry_->AddRef();
}
return false;
}
if (!rv)
return false;
DoChildIOCompleted(rv);
return true;
}
void SparseControl::DoChildIOCompleted(int result) {
LogChildOperationEnd(entry_->net_log(), operation_, result);
if (result < 0) {
result_ = result;
return;
}
UpdateRange(result);
result_ += result;
offset_ += result;
buf_len_ -= result;
if (buf_len_ && user_buf_)
user_buf_->DidConsume(result);
}
std::string SparseControl::GenerateChildKey() {
return GenerateChildName(entry_->GetKey(), sparse_header_.signature,
offset_ >> 20);
}
bool SparseControl::KillChildAndContinue(const std::string& key, bool fatal) {
SetChildBit(false);
child_->DoomImpl();
child_->Release();
child_ = NULL;
if (fatal) {
result_ = net::ERR_CACHE_READ_FAILURE;
return false;
}
return ContinueWithoutChild(key);
}
bool SparseControl::ChildPresent() {
int child_bit = static_cast<int>(offset_ >> 20);
if (children_map_.Size() <= child_bit)
return false;
return children_map_.Get(child_bit);
}
void SparseControl::SetChildBit(bool value) {
int child_bit = static_cast<int>(offset_ >> 20);
if (children_map_.Size() <= child_bit)
children_map_.Resize(Bitmap::RequiredArraySize(child_bit + 1) * 32, true);
children_map_.Set(child_bit, value);
}
bool SparseControl::VerifyRange() {
DCHECK_GE(result_, 0);
child_offset_ = static_cast<int>(offset_) & (kMaxEntrySize - 1);
child_len_ = std::min(buf_len_, kMaxEntrySize - child_offset_);
if (operation_ != kReadOperation)
return true;
int last_bit = (child_offset_ + child_len_ + 1023) >> 10;
int start = child_offset_ >> 10;
if (child_map_.FindNextBit(&start, last_bit, false)) {
DCHECK_GE(child_data_.header.last_block_len, 0);
DCHECK_LT(child_data_.header.last_block_len, kMaxEntrySize);
int partial_block_len = PartialBlockLength(start);
if (start == child_offset_ >> 10) {
if (partial_block_len <= (child_offset_ & (kBlockSize - 1)))
return false;
}
child_len_ = (start << 10) - child_offset_;
if (partial_block_len) {
child_len_ = std::min(child_len_ + partial_block_len, buf_len_);
}
buf_len_ = child_len_;
}
return true;
}
void SparseControl::UpdateRange(int result) {
if (result <= 0 || operation_ != kWriteOperation)
return;
DCHECK_GE(child_data_.header.last_block_len, 0);
DCHECK_LT(child_data_.header.last_block_len, kMaxEntrySize);
int first_bit = child_offset_ >> 10;
int block_offset = child_offset_ & (kBlockSize - 1);
if (block_offset && (child_data_.header.last_block != first_bit ||
child_data_.header.last_block_len < block_offset)) {
first_bit++;
}
int last_bit = (child_offset_ + result) >> 10;
block_offset = (child_offset_ + result) & (kBlockSize - 1);
if (first_bit > last_bit)
return;
if (block_offset && !child_map_.Get(last_bit)) {
child_data_.header.last_block = last_bit;
child_data_.header.last_block_len = block_offset;
} else {
child_data_.header.last_block = -1;
}
child_map_.SetRange(first_bit, last_bit, true);
}
int SparseControl::PartialBlockLength(int block_index) const {
if (block_index == child_data_.header.last_block)
return child_data_.header.last_block_len;
int entry_len = child_->GetDataSize(kSparseData);
if (block_index == entry_len >> 10)
return entry_len & (kBlockSize - 1);
return 0;
}
void SparseControl::InitChildData() {
EntryImpl* child = static_cast<EntryImpl*>(child_);
child->SetEntryFlags(CHILD_ENTRY);
memset(&child_data_, 0, sizeof(child_data_));
child_data_.header = sparse_header_;
scoped_refptr<net::WrappedIOBuffer> buf(
new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
int rv = child_->WriteData(kSparseIndex, 0, buf.get(), sizeof(child_data_),
CompletionCallback(), false);
if (rv != sizeof(child_data_))
DLOG(ERROR) << "Failed to save child data";
SetChildBit(true);
}
int SparseControl::DoGetAvailableRange() {
if (!child_)
return child_len_;
int last_bit = (child_offset_ + child_len_ + 1023) >> 10;
int start = child_offset_ >> 10;
int partial_start_bytes = PartialBlockLength(start);
int found = start;
int bits_found = child_map_.FindBits(&found, last_bit, true);
int block_offset = child_offset_ & (kBlockSize - 1);
if (!bits_found && partial_start_bytes <= block_offset)
return child_len_;
range_found_ = true;
int empty_start = std::max((found << 10) - child_offset_, 0);
int bytes_found = bits_found << 10;
bytes_found += PartialBlockLength(found + bits_found);
if (start == found)
bytes_found -= block_offset;
result_ = std::min(bytes_found, child_len_ - empty_start);
if (!bits_found) {
result_ = std::min(partial_start_bytes - block_offset, child_len_);
empty_start = 0;
}
if (empty_start)
offset_ += empty_start;
buf_len_ = 0;
return 0;
}
void SparseControl::DoUserCallback() {
DCHECK(!user_callback_.is_null());
CompletionCallback cb = user_callback_;
user_callback_.Reset();
user_buf_ = NULL;
pending_ = false;
operation_ = kNoOperation;
int rv = result_;
entry_->Release();
cb.Run(rv);
}
void SparseControl::DoAbortCallbacks() {
for (size_t i = 0; i < abort_callbacks_.size(); i++) {
CompletionCallback cb = abort_callbacks_[i];
if (i == abort_callbacks_.size() - 1)
abort_callbacks_.clear();
entry_->Release();
cb.Run(net::OK);
}
}
void SparseControl::OnChildIOCompleted(int result) {
DCHECK_NE(net::ERR_IO_PENDING, result);
DoChildIOCompleted(result);
if (abort_) {
abort_ = false;
if (entry_->net_log().IsLogging()) {
entry_->net_log().AddEvent(net::NetLog::TYPE_CANCELLED);
entry_->net_log().EndEvent(GetSparseEventType(operation_));
}
bool has_abort_callbacks = !abort_callbacks_.empty();
DoUserCallback();
if (has_abort_callbacks)
DoAbortCallbacks();
return;
}
DoChildrenIO();
}
}