| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/disk_cache/sparse_control.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/format_macros.h" | |
| 9 #include "base/logging.h" | |
| 10 #include "base/message_loop/message_loop.h" | |
| 11 #include "base/strings/string_util.h" | |
| 12 #include "base/strings/stringprintf.h" | |
| 13 #include "base/time/time.h" | |
| 14 #include "net/base/io_buffer.h" | |
| 15 #include "net/base/net_errors.h" | |
| 16 #include "net/disk_cache/backend_impl.h" | |
| 17 #include "net/disk_cache/entry_impl.h" | |
| 18 #include "net/disk_cache/file.h" | |
| 19 #include "net/disk_cache/net_log_parameters.h" | |
| 20 | |
| 21 using base::Time; | |
| 22 | |
| 23 namespace { | |
| 24 | |
| 25 // Stream of the sparse data index. | |
| 26 const int kSparseIndex = 2; | |
| 27 | |
| 28 // Stream of the sparse data. | |
| 29 const int kSparseData = 1; | |
| 30 | |
| 31 // We can have up to 64k children. | |
| 32 const int kMaxMapSize = 8 * 1024; | |
| 33 | |
| 34 // The maximum number of bytes that a child can store. | |
| 35 const int kMaxEntrySize = 0x100000; | |
| 36 | |
| 37 // The size of each data block (tracked by the child allocation bitmap). | |
| 38 const int kBlockSize = 1024; | |
| 39 | |
| 40 // Returns the name of a child entry given the base_name and signature of the | |
| 41 // parent and the child_id. | |
| 42 // If the entry is called entry_name, child entries will be named something | |
| 43 // like Range_entry_name:XXX:YYY where XXX is the entry signature and YYY is the | |
| 44 // number of the particular child. | |
| 45 std::string GenerateChildName(const std::string& base_name, int64 signature, | |
| 46 int64 child_id) { | |
| 47 return base::StringPrintf("Range_%s:%" PRIx64 ":%" PRIx64, base_name.c_str(), | |
| 48 signature, child_id); | |
| 49 } | |
| 50 | |
| 51 // This class deletes the children of a sparse entry. | |
| 52 class ChildrenDeleter | |
| 53 : public base::RefCounted<ChildrenDeleter>, | |
| 54 public disk_cache::FileIOCallback { | |
| 55 public: | |
| 56 ChildrenDeleter(disk_cache::BackendImpl* backend, const std::string& name) | |
| 57 : backend_(backend->GetWeakPtr()), name_(name), signature_(0) {} | |
| 58 | |
| 59 virtual void OnFileIOComplete(int bytes_copied) OVERRIDE; | |
| 60 | |
| 61 // Two ways of deleting the children: if we have the children map, use Start() | |
| 62 // directly, otherwise pass the data address to ReadData(). | |
| 63 void Start(char* buffer, int len); | |
| 64 void ReadData(disk_cache::Addr address, int len); | |
| 65 | |
| 66 private: | |
| 67 friend class base::RefCounted<ChildrenDeleter>; | |
| 68 virtual ~ChildrenDeleter() {} | |
| 69 | |
| 70 void DeleteChildren(); | |
| 71 | |
| 72 base::WeakPtr<disk_cache::BackendImpl> backend_; | |
| 73 std::string name_; | |
| 74 disk_cache::Bitmap children_map_; | |
| 75 int64 signature_; | |
| 76 scoped_ptr<char[]> buffer_; | |
| 77 DISALLOW_COPY_AND_ASSIGN(ChildrenDeleter); | |
| 78 }; | |
| 79 | |
| 80 // This is the callback of the file operation. | |
| 81 void ChildrenDeleter::OnFileIOComplete(int bytes_copied) { | |
| 82 char* buffer = buffer_.release(); | |
| 83 Start(buffer, bytes_copied); | |
| 84 } | |
| 85 | |
| 86 void ChildrenDeleter::Start(char* buffer, int len) { | |
| 87 buffer_.reset(buffer); | |
| 88 if (len < static_cast<int>(sizeof(disk_cache::SparseData))) | |
| 89 return Release(); | |
| 90 | |
| 91 // Just copy the information from |buffer|, delete |buffer| and start deleting | |
| 92 // the child entries. | |
| 93 disk_cache::SparseData* data = | |
| 94 reinterpret_cast<disk_cache::SparseData*>(buffer); | |
| 95 signature_ = data->header.signature; | |
| 96 | |
| 97 int num_bits = (len - sizeof(disk_cache::SparseHeader)) * 8; | |
| 98 children_map_.Resize(num_bits, false); | |
| 99 children_map_.SetMap(data->bitmap, num_bits / 32); | |
| 100 buffer_.reset(); | |
| 101 | |
| 102 DeleteChildren(); | |
| 103 } | |
| 104 | |
| 105 void ChildrenDeleter::ReadData(disk_cache::Addr address, int len) { | |
| 106 DCHECK(address.is_block_file()); | |
| 107 if (!backend_.get()) | |
| 108 return Release(); | |
| 109 | |
| 110 disk_cache::File* file(backend_->File(address)); | |
| 111 if (!file) | |
| 112 return Release(); | |
| 113 | |
| 114 size_t file_offset = address.start_block() * address.BlockSize() + | |
| 115 disk_cache::kBlockHeaderSize; | |
| 116 | |
| 117 buffer_.reset(new char[len]); | |
| 118 bool completed; | |
| 119 if (!file->Read(buffer_.get(), len, file_offset, this, &completed)) | |
| 120 return Release(); | |
| 121 | |
| 122 if (completed) | |
| 123 OnFileIOComplete(len); | |
| 124 | |
| 125 // And wait until OnFileIOComplete gets called. | |
| 126 } | |
| 127 | |
| 128 void ChildrenDeleter::DeleteChildren() { | |
| 129 int child_id = 0; | |
| 130 if (!children_map_.FindNextSetBit(&child_id) || !backend_.get()) { | |
| 131 // We are done. Just delete this object. | |
| 132 return Release(); | |
| 133 } | |
| 134 std::string child_name = GenerateChildName(name_, signature_, child_id); | |
| 135 backend_->SyncDoomEntry(child_name); | |
| 136 children_map_.Set(child_id, false); | |
| 137 | |
| 138 // Post a task to delete the next child. | |
| 139 base::MessageLoop::current()->PostTask( | |
| 140 FROM_HERE, base::Bind(&ChildrenDeleter::DeleteChildren, this)); | |
| 141 } | |
| 142 | |
| 143 // Returns the NetLog event type corresponding to a SparseOperation. | |
| 144 net::NetLog::EventType GetSparseEventType( | |
| 145 disk_cache::SparseControl::SparseOperation operation) { | |
| 146 switch (operation) { | |
| 147 case disk_cache::SparseControl::kReadOperation: | |
| 148 return net::NetLog::TYPE_SPARSE_READ; | |
| 149 case disk_cache::SparseControl::kWriteOperation: | |
| 150 return net::NetLog::TYPE_SPARSE_WRITE; | |
| 151 case disk_cache::SparseControl::kGetRangeOperation: | |
| 152 return net::NetLog::TYPE_SPARSE_GET_RANGE; | |
| 153 default: | |
| 154 NOTREACHED(); | |
| 155 return net::NetLog::TYPE_CANCELLED; | |
| 156 } | |
| 157 } | |
| 158 | |
| 159 // Logs the end event for |operation| on a child entry. Range operations log | |
| 160 // no events for each child they search through. | |
| 161 void LogChildOperationEnd(const net::BoundNetLog& net_log, | |
| 162 disk_cache::SparseControl::SparseOperation operation, | |
| 163 int result) { | |
| 164 if (net_log.IsLoggingAllEvents()) { | |
| 165 net::NetLog::EventType event_type; | |
| 166 switch (operation) { | |
| 167 case disk_cache::SparseControl::kReadOperation: | |
| 168 event_type = net::NetLog::TYPE_SPARSE_READ_CHILD_DATA; | |
| 169 break; | |
| 170 case disk_cache::SparseControl::kWriteOperation: | |
| 171 event_type = net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA; | |
| 172 break; | |
| 173 case disk_cache::SparseControl::kGetRangeOperation: | |
| 174 return; | |
| 175 default: | |
| 176 NOTREACHED(); | |
| 177 return; | |
| 178 } | |
| 179 net_log.EndEventWithNetErrorCode(event_type, result); | |
| 180 } | |
| 181 } | |
| 182 | |
| 183 } // namespace. | |
| 184 | |
| 185 namespace disk_cache { | |
| 186 | |
| 187 SparseControl::SparseControl(EntryImpl* entry) | |
| 188 : entry_(entry), | |
| 189 child_(NULL), | |
| 190 operation_(kNoOperation), | |
| 191 pending_(false), | |
| 192 finished_(false), | |
| 193 init_(false), | |
| 194 range_found_(false), | |
| 195 abort_(false), | |
| 196 child_map_(child_data_.bitmap, kNumSparseBits, kNumSparseBits / 32), | |
| 197 offset_(0), | |
| 198 buf_len_(0), | |
| 199 child_offset_(0), | |
| 200 child_len_(0), | |
| 201 result_(0) { | |
| 202 memset(&sparse_header_, 0, sizeof(sparse_header_)); | |
| 203 memset(&child_data_, 0, sizeof(child_data_)); | |
| 204 } | |
| 205 | |
| 206 SparseControl::~SparseControl() { | |
| 207 if (child_) | |
| 208 CloseChild(); | |
| 209 if (init_) | |
| 210 WriteSparseData(); | |
| 211 } | |
| 212 | |
| 213 int SparseControl::Init() { | |
| 214 DCHECK(!init_); | |
| 215 | |
| 216 // We should not have sparse data for the exposed entry. | |
| 217 if (entry_->GetDataSize(kSparseData)) | |
| 218 return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; | |
| 219 | |
| 220 // Now see if there is something where we store our data. | |
| 221 int rv = net::OK; | |
| 222 int data_len = entry_->GetDataSize(kSparseIndex); | |
| 223 if (!data_len) { | |
| 224 rv = CreateSparseEntry(); | |
| 225 } else { | |
| 226 rv = OpenSparseEntry(data_len); | |
| 227 } | |
| 228 | |
| 229 if (rv == net::OK) | |
| 230 init_ = true; | |
| 231 return rv; | |
| 232 } | |
| 233 | |
| 234 bool SparseControl::CouldBeSparse() const { | |
| 235 DCHECK(!init_); | |
| 236 | |
| 237 if (entry_->GetDataSize(kSparseData)) | |
| 238 return false; | |
| 239 | |
| 240 // We don't verify the data, just see if it could be there. | |
| 241 return (entry_->GetDataSize(kSparseIndex) != 0); | |
| 242 } | |
| 243 | |
| 244 int SparseControl::StartIO(SparseOperation op, int64 offset, net::IOBuffer* buf, | |
| 245 int buf_len, const CompletionCallback& callback) { | |
| 246 DCHECK(init_); | |
| 247 // We don't support simultaneous IO for sparse data. | |
| 248 if (operation_ != kNoOperation) | |
| 249 return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; | |
| 250 | |
| 251 if (offset < 0 || buf_len < 0) | |
| 252 return net::ERR_INVALID_ARGUMENT; | |
| 253 | |
| 254 // We only support up to 64 GB. | |
| 255 if (static_cast<uint64>(offset) + static_cast<unsigned int>(buf_len) >= | |
| 256 GG_UINT64_C(0x1000000000)) { | |
| 257 return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; | |
| 258 } | |
| 259 | |
| 260 DCHECK(!user_buf_.get()); | |
| 261 DCHECK(user_callback_.is_null()); | |
| 262 | |
| 263 if (!buf && (op == kReadOperation || op == kWriteOperation)) | |
| 264 return 0; | |
| 265 | |
| 266 // Copy the operation parameters. | |
| 267 operation_ = op; | |
| 268 offset_ = offset; | |
| 269 user_buf_ = buf ? new net::DrainableIOBuffer(buf, buf_len) : NULL; | |
| 270 buf_len_ = buf_len; | |
| 271 user_callback_ = callback; | |
| 272 | |
| 273 result_ = 0; | |
| 274 pending_ = false; | |
| 275 finished_ = false; | |
| 276 abort_ = false; | |
| 277 | |
| 278 if (entry_->net_log().IsLoggingAllEvents()) { | |
| 279 entry_->net_log().BeginEvent( | |
| 280 GetSparseEventType(operation_), | |
| 281 CreateNetLogSparseOperationCallback(offset_, buf_len_)); | |
| 282 } | |
| 283 DoChildrenIO(); | |
| 284 | |
| 285 if (!pending_) { | |
| 286 // Everything was done synchronously. | |
| 287 operation_ = kNoOperation; | |
| 288 user_buf_ = NULL; | |
| 289 user_callback_.Reset(); | |
| 290 return result_; | |
| 291 } | |
| 292 | |
| 293 return net::ERR_IO_PENDING; | |
| 294 } | |
| 295 | |
| 296 int SparseControl::GetAvailableRange(int64 offset, int len, int64* start) { | |
| 297 DCHECK(init_); | |
| 298 // We don't support simultaneous IO for sparse data. | |
| 299 if (operation_ != kNoOperation) | |
| 300 return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; | |
| 301 | |
| 302 DCHECK(start); | |
| 303 | |
| 304 range_found_ = false; | |
| 305 int result = StartIO( | |
| 306 kGetRangeOperation, offset, NULL, len, CompletionCallback()); | |
| 307 if (range_found_) { | |
| 308 *start = offset_; | |
| 309 return result; | |
| 310 } | |
| 311 | |
| 312 // This is a failure. We want to return a valid start value in any case. | |
| 313 *start = offset; | |
| 314 return result < 0 ? result : 0; // Don't mask error codes to the caller. | |
| 315 } | |
| 316 | |
| 317 void SparseControl::CancelIO() { | |
| 318 if (operation_ == kNoOperation) | |
| 319 return; | |
| 320 abort_ = true; | |
| 321 } | |
| 322 | |
| 323 int SparseControl::ReadyToUse(const CompletionCallback& callback) { | |
| 324 if (!abort_) | |
| 325 return net::OK; | |
| 326 | |
| 327 // We'll grab another reference to keep this object alive because we just have | |
| 328 // one extra reference due to the pending IO operation itself, but we'll | |
| 329 // release that one before invoking user_callback_. | |
| 330 entry_->AddRef(); // Balanced in DoAbortCallbacks. | |
| 331 abort_callbacks_.push_back(callback); | |
| 332 return net::ERR_IO_PENDING; | |
| 333 } | |
| 334 | |
| 335 // Static | |
| 336 void SparseControl::DeleteChildren(EntryImpl* entry) { | |
| 337 DCHECK(entry->GetEntryFlags() & PARENT_ENTRY); | |
| 338 int data_len = entry->GetDataSize(kSparseIndex); | |
| 339 if (data_len < static_cast<int>(sizeof(SparseData)) || | |
| 340 entry->GetDataSize(kSparseData)) | |
| 341 return; | |
| 342 | |
| 343 int map_len = data_len - sizeof(SparseHeader); | |
| 344 if (map_len > kMaxMapSize || map_len % 4) | |
| 345 return; | |
| 346 | |
| 347 char* buffer; | |
| 348 Addr address; | |
| 349 entry->GetData(kSparseIndex, &buffer, &address); | |
| 350 if (!buffer && !address.is_initialized()) | |
| 351 return; | |
| 352 | |
| 353 entry->net_log().AddEvent(net::NetLog::TYPE_SPARSE_DELETE_CHILDREN); | |
| 354 | |
| 355 DCHECK(entry->backend_.get()); | |
| 356 ChildrenDeleter* deleter = new ChildrenDeleter(entry->backend_.get(), | |
| 357 entry->GetKey()); | |
| 358 // The object will self destruct when finished. | |
| 359 deleter->AddRef(); | |
| 360 | |
| 361 if (buffer) { | |
| 362 base::MessageLoop::current()->PostTask( | |
| 363 FROM_HERE, | |
| 364 base::Bind(&ChildrenDeleter::Start, deleter, buffer, data_len)); | |
| 365 } else { | |
| 366 base::MessageLoop::current()->PostTask( | |
| 367 FROM_HERE, | |
| 368 base::Bind(&ChildrenDeleter::ReadData, deleter, address, data_len)); | |
| 369 } | |
| 370 } | |
| 371 | |
| 372 // We are going to start using this entry to store sparse data, so we have to | |
| 373 // initialize our control info. | |
| 374 int SparseControl::CreateSparseEntry() { | |
| 375 if (CHILD_ENTRY & entry_->GetEntryFlags()) | |
| 376 return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; | |
| 377 | |
| 378 memset(&sparse_header_, 0, sizeof(sparse_header_)); | |
| 379 sparse_header_.signature = Time::Now().ToInternalValue(); | |
| 380 sparse_header_.magic = kIndexMagic; | |
| 381 sparse_header_.parent_key_len = entry_->GetKey().size(); | |
| 382 children_map_.Resize(kNumSparseBits, true); | |
| 383 | |
| 384 // Save the header. The bitmap is saved in the destructor. | |
| 385 scoped_refptr<net::IOBuffer> buf( | |
| 386 new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_))); | |
| 387 | |
| 388 int rv = entry_->WriteData(kSparseIndex, 0, buf.get(), sizeof(sparse_header_), | |
| 389 CompletionCallback(), false); | |
| 390 if (rv != sizeof(sparse_header_)) { | |
| 391 DLOG(ERROR) << "Unable to save sparse_header_"; | |
| 392 return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; | |
| 393 } | |
| 394 | |
| 395 entry_->SetEntryFlags(PARENT_ENTRY); | |
| 396 return net::OK; | |
| 397 } | |
| 398 | |
| 399 // We are opening an entry from disk. Make sure that our control data is there. | |
| 400 int SparseControl::OpenSparseEntry(int data_len) { | |
| 401 if (data_len < static_cast<int>(sizeof(SparseData))) | |
| 402 return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; | |
| 403 | |
| 404 if (entry_->GetDataSize(kSparseData)) | |
| 405 return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; | |
| 406 | |
| 407 if (!(PARENT_ENTRY & entry_->GetEntryFlags())) | |
| 408 return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; | |
| 409 | |
| 410 // Dont't go over board with the bitmap. 8 KB gives us offsets up to 64 GB. | |
| 411 int map_len = data_len - sizeof(sparse_header_); | |
| 412 if (map_len > kMaxMapSize || map_len % 4) | |
| 413 return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; | |
| 414 | |
| 415 scoped_refptr<net::IOBuffer> buf( | |
| 416 new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_))); | |
| 417 | |
| 418 // Read header. | |
| 419 int rv = entry_->ReadData(kSparseIndex, 0, buf.get(), sizeof(sparse_header_), | |
| 420 CompletionCallback()); | |
| 421 if (rv != static_cast<int>(sizeof(sparse_header_))) | |
| 422 return net::ERR_CACHE_READ_FAILURE; | |
| 423 | |
| 424 // The real validation should be performed by the caller. This is just to | |
| 425 // double check. | |
| 426 if (sparse_header_.magic != kIndexMagic || | |
| 427 sparse_header_.parent_key_len != | |
| 428 static_cast<int>(entry_->GetKey().size())) | |
| 429 return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; | |
| 430 | |
| 431 // Read the actual bitmap. | |
| 432 buf = new net::IOBuffer(map_len); | |
| 433 rv = entry_->ReadData(kSparseIndex, sizeof(sparse_header_), buf.get(), | |
| 434 map_len, CompletionCallback()); | |
| 435 if (rv != map_len) | |
| 436 return net::ERR_CACHE_READ_FAILURE; | |
| 437 | |
| 438 // Grow the bitmap to the current size and copy the bits. | |
| 439 children_map_.Resize(map_len * 8, false); | |
| 440 children_map_.SetMap(reinterpret_cast<uint32*>(buf->data()), map_len); | |
| 441 return net::OK; | |
| 442 } | |
| 443 | |
| 444 bool SparseControl::OpenChild() { | |
| 445 DCHECK_GE(result_, 0); | |
| 446 | |
| 447 std::string key = GenerateChildKey(); | |
| 448 if (child_) { | |
| 449 // Keep using the same child or open another one?. | |
| 450 if (key == child_->GetKey()) | |
| 451 return true; | |
| 452 CloseChild(); | |
| 453 } | |
| 454 | |
| 455 // See if we are tracking this child. | |
| 456 if (!ChildPresent()) | |
| 457 return ContinueWithoutChild(key); | |
| 458 | |
| 459 if (!entry_->backend_.get()) | |
| 460 return false; | |
| 461 | |
| 462 child_ = entry_->backend_->OpenEntryImpl(key); | |
| 463 if (!child_) | |
| 464 return ContinueWithoutChild(key); | |
| 465 | |
| 466 EntryImpl* child = static_cast<EntryImpl*>(child_); | |
| 467 if (!(CHILD_ENTRY & child->GetEntryFlags()) || | |
| 468 child->GetDataSize(kSparseIndex) < | |
| 469 static_cast<int>(sizeof(child_data_))) | |
| 470 return KillChildAndContinue(key, false); | |
| 471 | |
| 472 scoped_refptr<net::WrappedIOBuffer> buf( | |
| 473 new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_))); | |
| 474 | |
| 475 // Read signature. | |
| 476 int rv = child_->ReadData(kSparseIndex, 0, buf.get(), sizeof(child_data_), | |
| 477 CompletionCallback()); | |
| 478 if (rv != sizeof(child_data_)) | |
| 479 return KillChildAndContinue(key, true); // This is a fatal failure. | |
| 480 | |
| 481 if (child_data_.header.signature != sparse_header_.signature || | |
| 482 child_data_.header.magic != kIndexMagic) | |
| 483 return KillChildAndContinue(key, false); | |
| 484 | |
| 485 if (child_data_.header.last_block_len < 0 || | |
| 486 child_data_.header.last_block_len > kBlockSize) { | |
| 487 // Make sure these values are always within range. | |
| 488 child_data_.header.last_block_len = 0; | |
| 489 child_data_.header.last_block = -1; | |
| 490 } | |
| 491 | |
| 492 return true; | |
| 493 } | |
| 494 | |
| 495 void SparseControl::CloseChild() { | |
| 496 scoped_refptr<net::WrappedIOBuffer> buf( | |
| 497 new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_))); | |
| 498 | |
| 499 // Save the allocation bitmap before closing the child entry. | |
| 500 int rv = child_->WriteData(kSparseIndex, 0, buf.get(), sizeof(child_data_), | |
| 501 CompletionCallback(), false); | |
| 502 if (rv != sizeof(child_data_)) | |
| 503 DLOG(ERROR) << "Failed to save child data"; | |
| 504 child_->Release(); | |
| 505 child_ = NULL; | |
| 506 } | |
| 507 | |
| 508 std::string SparseControl::GenerateChildKey() { | |
| 509 return GenerateChildName(entry_->GetKey(), sparse_header_.signature, | |
| 510 offset_ >> 20); | |
| 511 } | |
| 512 | |
| 513 // We are deleting the child because something went wrong. | |
| 514 bool SparseControl::KillChildAndContinue(const std::string& key, bool fatal) { | |
| 515 SetChildBit(false); | |
| 516 child_->DoomImpl(); | |
| 517 child_->Release(); | |
| 518 child_ = NULL; | |
| 519 if (fatal) { | |
| 520 result_ = net::ERR_CACHE_READ_FAILURE; | |
| 521 return false; | |
| 522 } | |
| 523 return ContinueWithoutChild(key); | |
| 524 } | |
| 525 | |
| 526 // We were not able to open this child; see what we can do. | |
| 527 bool SparseControl::ContinueWithoutChild(const std::string& key) { | |
| 528 if (kReadOperation == operation_) | |
| 529 return false; | |
| 530 if (kGetRangeOperation == operation_) | |
| 531 return true; | |
| 532 | |
| 533 if (!entry_->backend_.get()) | |
| 534 return false; | |
| 535 | |
| 536 child_ = entry_->backend_->CreateEntryImpl(key); | |
| 537 if (!child_) { | |
| 538 child_ = NULL; | |
| 539 result_ = net::ERR_CACHE_READ_FAILURE; | |
| 540 return false; | |
| 541 } | |
| 542 // Write signature. | |
| 543 InitChildData(); | |
| 544 return true; | |
| 545 } | |
| 546 | |
| 547 bool SparseControl::ChildPresent() { | |
| 548 int child_bit = static_cast<int>(offset_ >> 20); | |
| 549 if (children_map_.Size() <= child_bit) | |
| 550 return false; | |
| 551 | |
| 552 return children_map_.Get(child_bit); | |
| 553 } | |
| 554 | |
| 555 void SparseControl::SetChildBit(bool value) { | |
| 556 int child_bit = static_cast<int>(offset_ >> 20); | |
| 557 | |
| 558 // We may have to increase the bitmap of child entries. | |
| 559 if (children_map_.Size() <= child_bit) | |
| 560 children_map_.Resize(Bitmap::RequiredArraySize(child_bit + 1) * 32, true); | |
| 561 | |
| 562 children_map_.Set(child_bit, value); | |
| 563 } | |
| 564 | |
| 565 void SparseControl::WriteSparseData() { | |
| 566 scoped_refptr<net::IOBuffer> buf(new net::WrappedIOBuffer( | |
| 567 reinterpret_cast<const char*>(children_map_.GetMap()))); | |
| 568 | |
| 569 int len = children_map_.ArraySize() * 4; | |
| 570 int rv = entry_->WriteData(kSparseIndex, sizeof(sparse_header_), buf.get(), | |
| 571 len, CompletionCallback(), false); | |
| 572 if (rv != len) { | |
| 573 DLOG(ERROR) << "Unable to save sparse map"; | |
| 574 } | |
| 575 } | |
| 576 | |
| 577 bool SparseControl::VerifyRange() { | |
| 578 DCHECK_GE(result_, 0); | |
| 579 | |
| 580 child_offset_ = static_cast<int>(offset_) & (kMaxEntrySize - 1); | |
| 581 child_len_ = std::min(buf_len_, kMaxEntrySize - child_offset_); | |
| 582 | |
| 583 // We can write to (or get info from) anywhere in this child. | |
| 584 if (operation_ != kReadOperation) | |
| 585 return true; | |
| 586 | |
| 587 // Check that there are no holes in this range. | |
| 588 int last_bit = (child_offset_ + child_len_ + 1023) >> 10; | |
| 589 int start = child_offset_ >> 10; | |
| 590 if (child_map_.FindNextBit(&start, last_bit, false)) { | |
| 591 // Something is not here. | |
| 592 DCHECK_GE(child_data_.header.last_block_len, 0); | |
| 593 DCHECK_LT(child_data_.header.last_block_len, kMaxEntrySize); | |
| 594 int partial_block_len = PartialBlockLength(start); | |
| 595 if (start == child_offset_ >> 10) { | |
| 596 // It looks like we don't have anything. | |
| 597 if (partial_block_len <= (child_offset_ & (kBlockSize - 1))) | |
| 598 return false; | |
| 599 } | |
| 600 | |
| 601 // We have the first part. | |
| 602 child_len_ = (start << 10) - child_offset_; | |
| 603 if (partial_block_len) { | |
| 604 // We may have a few extra bytes. | |
| 605 child_len_ = std::min(child_len_ + partial_block_len, buf_len_); | |
| 606 } | |
| 607 // There is no need to read more after this one. | |
| 608 buf_len_ = child_len_; | |
| 609 } | |
| 610 return true; | |
| 611 } | |
| 612 | |
| 613 void SparseControl::UpdateRange(int result) { | |
| 614 if (result <= 0 || operation_ != kWriteOperation) | |
| 615 return; | |
| 616 | |
| 617 DCHECK_GE(child_data_.header.last_block_len, 0); | |
| 618 DCHECK_LT(child_data_.header.last_block_len, kMaxEntrySize); | |
| 619 | |
| 620 // Write the bitmap. | |
| 621 int first_bit = child_offset_ >> 10; | |
| 622 int block_offset = child_offset_ & (kBlockSize - 1); | |
| 623 if (block_offset && (child_data_.header.last_block != first_bit || | |
| 624 child_data_.header.last_block_len < block_offset)) { | |
| 625 // The first block is not completely filled; ignore it. | |
| 626 first_bit++; | |
| 627 } | |
| 628 | |
| 629 int last_bit = (child_offset_ + result) >> 10; | |
| 630 block_offset = (child_offset_ + result) & (kBlockSize - 1); | |
| 631 | |
| 632 // This condition will hit with the following criteria: | |
| 633 // 1. The first byte doesn't follow the last write. | |
| 634 // 2. The first byte is in the middle of a block. | |
| 635 // 3. The first byte and the last byte are in the same block. | |
| 636 if (first_bit > last_bit) | |
| 637 return; | |
| 638 | |
| 639 if (block_offset && !child_map_.Get(last_bit)) { | |
| 640 // The last block is not completely filled; save it for later. | |
| 641 child_data_.header.last_block = last_bit; | |
| 642 child_data_.header.last_block_len = block_offset; | |
| 643 } else { | |
| 644 child_data_.header.last_block = -1; | |
| 645 } | |
| 646 | |
| 647 child_map_.SetRange(first_bit, last_bit, true); | |
| 648 } | |
| 649 | |
| 650 int SparseControl::PartialBlockLength(int block_index) const { | |
| 651 if (block_index == child_data_.header.last_block) | |
| 652 return child_data_.header.last_block_len; | |
| 653 | |
| 654 // This may be the last stored index. | |
| 655 int entry_len = child_->GetDataSize(kSparseData); | |
| 656 if (block_index == entry_len >> 10) | |
| 657 return entry_len & (kBlockSize - 1); | |
| 658 | |
| 659 // This is really empty. | |
| 660 return 0; | |
| 661 } | |
| 662 | |
| 663 void SparseControl::InitChildData() { | |
| 664 // We know the real type of child_. | |
| 665 EntryImpl* child = static_cast<EntryImpl*>(child_); | |
| 666 child->SetEntryFlags(CHILD_ENTRY); | |
| 667 | |
| 668 memset(&child_data_, 0, sizeof(child_data_)); | |
| 669 child_data_.header = sparse_header_; | |
| 670 | |
| 671 scoped_refptr<net::WrappedIOBuffer> buf( | |
| 672 new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_))); | |
| 673 | |
| 674 int rv = child_->WriteData(kSparseIndex, 0, buf.get(), sizeof(child_data_), | |
| 675 CompletionCallback(), false); | |
| 676 if (rv != sizeof(child_data_)) | |
| 677 DLOG(ERROR) << "Failed to save child data"; | |
| 678 SetChildBit(true); | |
| 679 } | |
| 680 | |
| 681 void SparseControl::DoChildrenIO() { | |
| 682 while (DoChildIO()) continue; | |
| 683 | |
| 684 // Range operations are finished synchronously, often without setting | |
| 685 // |finished_| to true. | |
| 686 if (kGetRangeOperation == operation_ && | |
| 687 entry_->net_log().IsLoggingAllEvents()) { | |
| 688 entry_->net_log().EndEvent( | |
| 689 net::NetLog::TYPE_SPARSE_GET_RANGE, | |
| 690 CreateNetLogGetAvailableRangeResultCallback(offset_, result_)); | |
| 691 } | |
| 692 if (finished_) { | |
| 693 if (kGetRangeOperation != operation_ && | |
| 694 entry_->net_log().IsLoggingAllEvents()) { | |
| 695 entry_->net_log().EndEvent(GetSparseEventType(operation_)); | |
| 696 } | |
| 697 if (pending_) | |
| 698 DoUserCallback(); // Don't touch this object after this point. | |
| 699 } | |
| 700 } | |
| 701 | |
| 702 bool SparseControl::DoChildIO() { | |
| 703 finished_ = true; | |
| 704 if (!buf_len_ || result_ < 0) | |
| 705 return false; | |
| 706 | |
| 707 if (!OpenChild()) | |
| 708 return false; | |
| 709 | |
| 710 if (!VerifyRange()) | |
| 711 return false; | |
| 712 | |
| 713 // We have more work to do. Let's not trigger a callback to the caller. | |
| 714 finished_ = false; | |
| 715 CompletionCallback callback; | |
| 716 if (!user_callback_.is_null()) { | |
| 717 callback = | |
| 718 base::Bind(&SparseControl::OnChildIOCompleted, base::Unretained(this)); | |
| 719 } | |
| 720 | |
| 721 int rv = 0; | |
| 722 switch (operation_) { | |
| 723 case kReadOperation: | |
| 724 if (entry_->net_log().IsLoggingAllEvents()) { | |
| 725 entry_->net_log().BeginEvent( | |
| 726 net::NetLog::TYPE_SPARSE_READ_CHILD_DATA, | |
| 727 CreateNetLogSparseReadWriteCallback(child_->net_log().source(), | |
| 728 child_len_)); | |
| 729 } | |
| 730 rv = child_->ReadDataImpl(kSparseData, child_offset_, user_buf_.get(), | |
| 731 child_len_, callback); | |
| 732 break; | |
| 733 case kWriteOperation: | |
| 734 if (entry_->net_log().IsLoggingAllEvents()) { | |
| 735 entry_->net_log().BeginEvent( | |
| 736 net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA, | |
| 737 CreateNetLogSparseReadWriteCallback(child_->net_log().source(), | |
| 738 child_len_)); | |
| 739 } | |
| 740 rv = child_->WriteDataImpl(kSparseData, child_offset_, user_buf_.get(), | |
| 741 child_len_, callback, false); | |
| 742 break; | |
| 743 case kGetRangeOperation: | |
| 744 rv = DoGetAvailableRange(); | |
| 745 break; | |
| 746 default: | |
| 747 NOTREACHED(); | |
| 748 } | |
| 749 | |
| 750 if (rv == net::ERR_IO_PENDING) { | |
| 751 if (!pending_) { | |
| 752 pending_ = true; | |
| 753 // The child will protect himself against closing the entry while IO is in | |
| 754 // progress. However, this entry can still be closed, and that would not | |
| 755 // be a good thing for us, so we increase the refcount until we're | |
| 756 // finished doing sparse stuff. | |
| 757 entry_->AddRef(); // Balanced in DoUserCallback. | |
| 758 } | |
| 759 return false; | |
| 760 } | |
| 761 if (!rv) | |
| 762 return false; | |
| 763 | |
| 764 DoChildIOCompleted(rv); | |
| 765 return true; | |
| 766 } | |
| 767 | |
| 768 int SparseControl::DoGetAvailableRange() { | |
| 769 if (!child_) | |
| 770 return child_len_; // Move on to the next child. | |
| 771 | |
| 772 // Check that there are no holes in this range. | |
| 773 int last_bit = (child_offset_ + child_len_ + 1023) >> 10; | |
| 774 int start = child_offset_ >> 10; | |
| 775 int partial_start_bytes = PartialBlockLength(start); | |
| 776 int found = start; | |
| 777 int bits_found = child_map_.FindBits(&found, last_bit, true); | |
| 778 | |
| 779 // We don't care if there is a partial block in the middle of the range. | |
| 780 int block_offset = child_offset_ & (kBlockSize - 1); | |
| 781 if (!bits_found && partial_start_bytes <= block_offset) | |
| 782 return child_len_; | |
| 783 | |
| 784 // We are done. Just break the loop and reset result_ to our real result. | |
| 785 range_found_ = true; | |
| 786 | |
| 787 // found now points to the first 1. Lets see if we have zeros before it. | |
| 788 int empty_start = std::max((found << 10) - child_offset_, 0); | |
| 789 | |
| 790 int bytes_found = bits_found << 10; | |
| 791 bytes_found += PartialBlockLength(found + bits_found); | |
| 792 | |
| 793 if (start == found) | |
| 794 bytes_found -= block_offset; | |
| 795 | |
| 796 // If the user is searching past the end of this child, bits_found is the | |
| 797 // right result; otherwise, we have some empty space at the start of this | |
| 798 // query that we have to subtract from the range that we searched. | |
| 799 result_ = std::min(bytes_found, child_len_ - empty_start); | |
| 800 | |
| 801 if (!bits_found) { | |
| 802 result_ = std::min(partial_start_bytes - block_offset, child_len_); | |
| 803 empty_start = 0; | |
| 804 } | |
| 805 | |
| 806 // Only update offset_ when this query found zeros at the start. | |
| 807 if (empty_start) | |
| 808 offset_ += empty_start; | |
| 809 | |
| 810 // This will actually break the loop. | |
| 811 buf_len_ = 0; | |
| 812 return 0; | |
| 813 } | |
| 814 | |
| 815 void SparseControl::DoChildIOCompleted(int result) { | |
| 816 LogChildOperationEnd(entry_->net_log(), operation_, result); | |
| 817 if (result < 0) { | |
| 818 // We fail the whole operation if we encounter an error. | |
| 819 result_ = result; | |
| 820 return; | |
| 821 } | |
| 822 | |
| 823 UpdateRange(result); | |
| 824 | |
| 825 result_ += result; | |
| 826 offset_ += result; | |
| 827 buf_len_ -= result; | |
| 828 | |
| 829 // We'll be reusing the user provided buffer for the next chunk. | |
| 830 if (buf_len_ && user_buf_.get()) | |
| 831 user_buf_->DidConsume(result); | |
| 832 } | |
| 833 | |
| 834 void SparseControl::OnChildIOCompleted(int result) { | |
| 835 DCHECK_NE(net::ERR_IO_PENDING, result); | |
| 836 DoChildIOCompleted(result); | |
| 837 | |
| 838 if (abort_) { | |
| 839 // We'll return the current result of the operation, which may be less than | |
| 840 // the bytes to read or write, but the user cancelled the operation. | |
| 841 abort_ = false; | |
| 842 if (entry_->net_log().IsLoggingAllEvents()) { | |
| 843 entry_->net_log().AddEvent(net::NetLog::TYPE_CANCELLED); | |
| 844 entry_->net_log().EndEvent(GetSparseEventType(operation_)); | |
| 845 } | |
| 846 // We have an indirect reference to this object for every callback so if | |
| 847 // there is only one callback, we may delete this object before reaching | |
| 848 // DoAbortCallbacks. | |
| 849 bool has_abort_callbacks = !abort_callbacks_.empty(); | |
| 850 DoUserCallback(); | |
| 851 if (has_abort_callbacks) | |
| 852 DoAbortCallbacks(); | |
| 853 return; | |
| 854 } | |
| 855 | |
| 856 // We are running a callback from the message loop. It's time to restart what | |
| 857 // we were doing before. | |
| 858 DoChildrenIO(); | |
| 859 } | |
| 860 | |
| 861 void SparseControl::DoUserCallback() { | |
| 862 DCHECK(!user_callback_.is_null()); | |
| 863 CompletionCallback cb = user_callback_; | |
| 864 user_callback_.Reset(); | |
| 865 user_buf_ = NULL; | |
| 866 pending_ = false; | |
| 867 operation_ = kNoOperation; | |
| 868 int rv = result_; | |
| 869 entry_->Release(); // Don't touch object after this line. | |
| 870 cb.Run(rv); | |
| 871 } | |
| 872 | |
| 873 void SparseControl::DoAbortCallbacks() { | |
| 874 for (size_t i = 0; i < abort_callbacks_.size(); i++) { | |
| 875 // Releasing all references to entry_ may result in the destruction of this | |
| 876 // object so we should not be touching it after the last Release(). | |
| 877 CompletionCallback cb = abort_callbacks_[i]; | |
| 878 if (i == abort_callbacks_.size() - 1) | |
| 879 abort_callbacks_.clear(); | |
| 880 | |
| 881 entry_->Release(); // Don't touch object after this line. | |
| 882 cb.Run(net::OK); | |
| 883 } | |
| 884 } | |
| 885 | |
| 886 } // namespace disk_cache | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 121643003:
Reorganize net/disk_cache into backend specific directories. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src