| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013 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/simple/simple_synchronous_entry.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <cstring> | |
| 9 #include <functional> | |
| 10 #include <limits> | |
| 11 | |
| 12 #include "base/basictypes.h" | |
| 13 #include "base/compiler_specific.h" | |
| 14 #include "base/files/file_util.h" | |
| 15 #include "base/hash.h" | |
| 16 #include "base/location.h" | |
| 17 #include "base/numerics/safe_conversions.h" | |
| 18 #include "base/sha1.h" | |
| 19 #include "base/strings/stringprintf.h" | |
| 20 #include "net/base/io_buffer.h" | |
| 21 #include "net/base/net_errors.h" | |
| 22 #include "net/disk_cache/simple/simple_backend_version.h" | |
| 23 #include "net/disk_cache/simple/simple_histogram_macros.h" | |
| 24 #include "net/disk_cache/simple/simple_util.h" | |
| 25 #include "third_party/zlib/zlib.h" | |
| 26 | |
| 27 using base::File; | |
| 28 using base::FilePath; | |
| 29 using base::Time; | |
| 30 | |
| 31 namespace { | |
| 32 | |
| 33 // Used in histograms, please only add entries at the end. | |
| 34 enum OpenEntryResult { | |
| 35 OPEN_ENTRY_SUCCESS = 0, | |
| 36 OPEN_ENTRY_PLATFORM_FILE_ERROR = 1, | |
| 37 OPEN_ENTRY_CANT_READ_HEADER = 2, | |
| 38 OPEN_ENTRY_BAD_MAGIC_NUMBER = 3, | |
| 39 OPEN_ENTRY_BAD_VERSION = 4, | |
| 40 OPEN_ENTRY_CANT_READ_KEY = 5, | |
| 41 // OPEN_ENTRY_KEY_MISMATCH = 6, Deprecated. | |
| 42 OPEN_ENTRY_KEY_HASH_MISMATCH = 7, | |
| 43 OPEN_ENTRY_SPARSE_OPEN_FAILED = 8, | |
| 44 OPEN_ENTRY_MAX = 9, | |
| 45 }; | |
| 46 | |
| 47 // Used in histograms, please only add entries at the end. | |
| 48 enum WriteResult { | |
| 49 WRITE_RESULT_SUCCESS = 0, | |
| 50 WRITE_RESULT_PRETRUNCATE_FAILURE, | |
| 51 WRITE_RESULT_WRITE_FAILURE, | |
| 52 WRITE_RESULT_TRUNCATE_FAILURE, | |
| 53 WRITE_RESULT_LAZY_STREAM_ENTRY_DOOMED, | |
| 54 WRITE_RESULT_LAZY_CREATE_FAILURE, | |
| 55 WRITE_RESULT_LAZY_INITIALIZE_FAILURE, | |
| 56 WRITE_RESULT_MAX, | |
| 57 }; | |
| 58 | |
| 59 // Used in histograms, please only add entries at the end. | |
| 60 enum CheckEOFResult { | |
| 61 CHECK_EOF_RESULT_SUCCESS, | |
| 62 CHECK_EOF_RESULT_READ_FAILURE, | |
| 63 CHECK_EOF_RESULT_MAGIC_NUMBER_MISMATCH, | |
| 64 CHECK_EOF_RESULT_CRC_MISMATCH, | |
| 65 CHECK_EOF_RESULT_MAX, | |
| 66 }; | |
| 67 | |
| 68 // Used in histograms, please only add entries at the end. | |
| 69 enum CloseResult { | |
| 70 CLOSE_RESULT_SUCCESS, | |
| 71 CLOSE_RESULT_WRITE_FAILURE, | |
| 72 }; | |
| 73 | |
| 74 void RecordSyncOpenResult(net::CacheType cache_type, | |
| 75 OpenEntryResult result, | |
| 76 bool had_index) { | |
| 77 DCHECK_LT(result, OPEN_ENTRY_MAX); | |
| 78 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 79 "SyncOpenResult", cache_type, result, OPEN_ENTRY_MAX); | |
| 80 if (had_index) { | |
| 81 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 82 "SyncOpenResult_WithIndex", cache_type, | |
| 83 result, OPEN_ENTRY_MAX); | |
| 84 } else { | |
| 85 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 86 "SyncOpenResult_WithoutIndex", cache_type, | |
| 87 result, OPEN_ENTRY_MAX); | |
| 88 } | |
| 89 } | |
| 90 | |
| 91 void RecordWriteResult(net::CacheType cache_type, WriteResult result) { | |
| 92 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 93 "SyncWriteResult", cache_type, result, WRITE_RESULT_MAX); | |
| 94 } | |
| 95 | |
| 96 void RecordCheckEOFResult(net::CacheType cache_type, CheckEOFResult result) { | |
| 97 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 98 "SyncCheckEOFResult", cache_type, | |
| 99 result, CHECK_EOF_RESULT_MAX); | |
| 100 } | |
| 101 | |
| 102 void RecordCloseResult(net::CacheType cache_type, CloseResult result) { | |
| 103 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 104 "SyncCloseResult", cache_type, result, WRITE_RESULT_MAX); | |
| 105 } | |
| 106 | |
| 107 bool CanOmitEmptyFile(int file_index) { | |
| 108 DCHECK_GE(file_index, 0); | |
| 109 DCHECK_LT(file_index, disk_cache::kSimpleEntryFileCount); | |
| 110 return file_index == disk_cache::simple_util::GetFileIndexFromStreamIndex(2); | |
| 111 } | |
| 112 | |
| 113 } // namespace | |
| 114 | |
| 115 namespace disk_cache { | |
| 116 | |
| 117 using simple_util::GetEntryHashKey; | |
| 118 using simple_util::GetFilenameFromEntryHashAndFileIndex; | |
| 119 using simple_util::GetSparseFilenameFromEntryHash; | |
| 120 using simple_util::GetDataSizeFromKeyAndFileSize; | |
| 121 using simple_util::GetFileSizeFromKeyAndDataSize; | |
| 122 using simple_util::GetFileIndexFromStreamIndex; | |
| 123 | |
| 124 SimpleEntryStat::SimpleEntryStat(base::Time last_used, | |
| 125 base::Time last_modified, | |
| 126 const int32 data_size[], | |
| 127 const int32 sparse_data_size) | |
| 128 : last_used_(last_used), | |
| 129 last_modified_(last_modified), | |
| 130 sparse_data_size_(sparse_data_size) { | |
| 131 memcpy(data_size_, data_size, sizeof(data_size_)); | |
| 132 } | |
| 133 | |
| 134 int SimpleEntryStat::GetOffsetInFile(const std::string& key, | |
| 135 int offset, | |
| 136 int stream_index) const { | |
| 137 const size_t headers_size = sizeof(SimpleFileHeader) + key.size(); | |
| 138 const size_t additional_offset = | |
| 139 stream_index == 0 ? data_size_[1] + sizeof(SimpleFileEOF) : 0; | |
| 140 return headers_size + offset + additional_offset; | |
| 141 } | |
| 142 | |
| 143 int SimpleEntryStat::GetEOFOffsetInFile(const std::string& key, | |
| 144 int stream_index) const { | |
| 145 return GetOffsetInFile(key, data_size_[stream_index], stream_index); | |
| 146 } | |
| 147 | |
| 148 int SimpleEntryStat::GetLastEOFOffsetInFile(const std::string& key, | |
| 149 int stream_index) const { | |
| 150 const int file_index = GetFileIndexFromStreamIndex(stream_index); | |
| 151 const int eof_data_offset = | |
| 152 file_index == 0 ? data_size_[0] + data_size_[1] + sizeof(SimpleFileEOF) | |
| 153 : data_size_[2]; | |
| 154 return GetOffsetInFile(key, eof_data_offset, stream_index); | |
| 155 } | |
| 156 | |
| 157 int64 SimpleEntryStat::GetFileSize(const std::string& key, | |
| 158 int file_index) const { | |
| 159 const int32 total_data_size = | |
| 160 file_index == 0 ? data_size_[0] + data_size_[1] + sizeof(SimpleFileEOF) | |
| 161 : data_size_[2]; | |
| 162 return GetFileSizeFromKeyAndDataSize(key, total_data_size); | |
| 163 } | |
| 164 | |
| 165 SimpleEntryCreationResults::SimpleEntryCreationResults( | |
| 166 SimpleEntryStat entry_stat) | |
| 167 : sync_entry(NULL), | |
| 168 entry_stat(entry_stat), | |
| 169 stream_0_crc32(crc32(0, Z_NULL, 0)), | |
| 170 result(net::OK) { | |
| 171 } | |
| 172 | |
| 173 SimpleEntryCreationResults::~SimpleEntryCreationResults() { | |
| 174 } | |
| 175 | |
| 176 SimpleSynchronousEntry::CRCRecord::CRCRecord() : index(-1), | |
| 177 has_crc32(false), | |
| 178 data_crc32(0) { | |
| 179 } | |
| 180 | |
| 181 SimpleSynchronousEntry::CRCRecord::CRCRecord(int index_p, | |
| 182 bool has_crc32_p, | |
| 183 uint32 data_crc32_p) | |
| 184 : index(index_p), | |
| 185 has_crc32(has_crc32_p), | |
| 186 data_crc32(data_crc32_p) {} | |
| 187 | |
| 188 SimpleSynchronousEntry::EntryOperationData::EntryOperationData(int index_p, | |
| 189 int offset_p, | |
| 190 int buf_len_p) | |
| 191 : index(index_p), | |
| 192 offset(offset_p), | |
| 193 buf_len(buf_len_p) {} | |
| 194 | |
| 195 SimpleSynchronousEntry::EntryOperationData::EntryOperationData(int index_p, | |
| 196 int offset_p, | |
| 197 int buf_len_p, | |
| 198 bool truncate_p, | |
| 199 bool doomed_p) | |
| 200 : index(index_p), | |
| 201 offset(offset_p), | |
| 202 buf_len(buf_len_p), | |
| 203 truncate(truncate_p), | |
| 204 doomed(doomed_p) {} | |
| 205 | |
| 206 SimpleSynchronousEntry::EntryOperationData::EntryOperationData( | |
| 207 int64 sparse_offset_p, | |
| 208 int buf_len_p) | |
| 209 : sparse_offset(sparse_offset_p), | |
| 210 buf_len(buf_len_p) {} | |
| 211 | |
| 212 // static | |
| 213 void SimpleSynchronousEntry::OpenEntry( | |
| 214 net::CacheType cache_type, | |
| 215 const FilePath& path, | |
| 216 const uint64 entry_hash, | |
| 217 bool had_index, | |
| 218 SimpleEntryCreationResults *out_results) { | |
| 219 SimpleSynchronousEntry* sync_entry = | |
| 220 new SimpleSynchronousEntry(cache_type, path, "", entry_hash); | |
| 221 out_results->result = | |
| 222 sync_entry->InitializeForOpen(had_index, | |
| 223 &out_results->entry_stat, | |
| 224 &out_results->stream_0_data, | |
| 225 &out_results->stream_0_crc32); | |
| 226 if (out_results->result != net::OK) { | |
| 227 sync_entry->Doom(); | |
| 228 delete sync_entry; | |
| 229 out_results->sync_entry = NULL; | |
| 230 out_results->stream_0_data = NULL; | |
| 231 return; | |
| 232 } | |
| 233 out_results->sync_entry = sync_entry; | |
| 234 } | |
| 235 | |
| 236 // static | |
| 237 void SimpleSynchronousEntry::CreateEntry( | |
| 238 net::CacheType cache_type, | |
| 239 const FilePath& path, | |
| 240 const std::string& key, | |
| 241 const uint64 entry_hash, | |
| 242 bool had_index, | |
| 243 SimpleEntryCreationResults *out_results) { | |
| 244 DCHECK_EQ(entry_hash, GetEntryHashKey(key)); | |
| 245 SimpleSynchronousEntry* sync_entry = | |
| 246 new SimpleSynchronousEntry(cache_type, path, key, entry_hash); | |
| 247 out_results->result = sync_entry->InitializeForCreate( | |
| 248 had_index, &out_results->entry_stat); | |
| 249 if (out_results->result != net::OK) { | |
| 250 if (out_results->result != net::ERR_FILE_EXISTS) | |
| 251 sync_entry->Doom(); | |
| 252 delete sync_entry; | |
| 253 out_results->sync_entry = NULL; | |
| 254 return; | |
| 255 } | |
| 256 out_results->sync_entry = sync_entry; | |
| 257 } | |
| 258 | |
| 259 // static | |
| 260 int SimpleSynchronousEntry::DoomEntry( | |
| 261 const FilePath& path, | |
| 262 uint64 entry_hash) { | |
| 263 const bool deleted_well = DeleteFilesForEntryHash(path, entry_hash); | |
| 264 return deleted_well ? net::OK : net::ERR_FAILED; | |
| 265 } | |
| 266 | |
| 267 // static | |
| 268 int SimpleSynchronousEntry::DoomEntrySet( | |
| 269 const std::vector<uint64>* key_hashes, | |
| 270 const FilePath& path) { | |
| 271 const size_t did_delete_count = std::count_if( | |
| 272 key_hashes->begin(), key_hashes->end(), std::bind1st( | |
| 273 std::ptr_fun(SimpleSynchronousEntry::DeleteFilesForEntryHash), path)); | |
| 274 return (did_delete_count == key_hashes->size()) ? net::OK : net::ERR_FAILED; | |
| 275 } | |
| 276 | |
| 277 void SimpleSynchronousEntry::ReadData(const EntryOperationData& in_entry_op, | |
| 278 net::IOBuffer* out_buf, | |
| 279 uint32* out_crc32, | |
| 280 SimpleEntryStat* entry_stat, | |
| 281 int* out_result) const { | |
| 282 DCHECK(initialized_); | |
| 283 DCHECK_NE(0, in_entry_op.index); | |
| 284 const int64 file_offset = | |
| 285 entry_stat->GetOffsetInFile(key_, in_entry_op.offset, in_entry_op.index); | |
| 286 int file_index = GetFileIndexFromStreamIndex(in_entry_op.index); | |
| 287 // Zero-length reads and reads to the empty streams of omitted files should | |
| 288 // be handled in the SimpleEntryImpl. | |
| 289 DCHECK_GT(in_entry_op.buf_len, 0); | |
| 290 DCHECK(!empty_file_omitted_[file_index]); | |
| 291 File* file = const_cast<File*>(&files_[file_index]); | |
| 292 int bytes_read = | |
| 293 file->Read(file_offset, out_buf->data(), in_entry_op.buf_len); | |
| 294 if (bytes_read > 0) { | |
| 295 entry_stat->set_last_used(Time::Now()); | |
| 296 *out_crc32 = crc32(crc32(0L, Z_NULL, 0), | |
| 297 reinterpret_cast<const Bytef*>(out_buf->data()), | |
| 298 bytes_read); | |
| 299 } | |
| 300 if (bytes_read >= 0) { | |
| 301 *out_result = bytes_read; | |
| 302 } else { | |
| 303 *out_result = net::ERR_CACHE_READ_FAILURE; | |
| 304 Doom(); | |
| 305 } | |
| 306 } | |
| 307 | |
| 308 void SimpleSynchronousEntry::WriteData(const EntryOperationData& in_entry_op, | |
| 309 net::IOBuffer* in_buf, | |
| 310 SimpleEntryStat* out_entry_stat, | |
| 311 int* out_result) { | |
| 312 DCHECK(initialized_); | |
| 313 DCHECK_NE(0, in_entry_op.index); | |
| 314 int index = in_entry_op.index; | |
| 315 int file_index = GetFileIndexFromStreamIndex(index); | |
| 316 int offset = in_entry_op.offset; | |
| 317 int buf_len = in_entry_op.buf_len; | |
| 318 bool truncate = in_entry_op.truncate; | |
| 319 bool doomed = in_entry_op.doomed; | |
| 320 const int64 file_offset = out_entry_stat->GetOffsetInFile( | |
| 321 key_, in_entry_op.offset, in_entry_op.index); | |
| 322 bool extending_by_write = offset + buf_len > out_entry_stat->data_size(index); | |
| 323 | |
| 324 if (empty_file_omitted_[file_index]) { | |
| 325 // Don't create a new file if the entry has been doomed, to avoid it being | |
| 326 // mixed up with a newly-created entry with the same key. | |
| 327 if (doomed) { | |
| 328 DLOG(WARNING) << "Rejecting write to lazily omitted stream " | |
| 329 << in_entry_op.index << " of doomed cache entry."; | |
| 330 RecordWriteResult(cache_type_, WRITE_RESULT_LAZY_STREAM_ENTRY_DOOMED); | |
| 331 *out_result = net::ERR_CACHE_WRITE_FAILURE; | |
| 332 return; | |
| 333 } | |
| 334 File::Error error; | |
| 335 if (!MaybeCreateFile(file_index, FILE_REQUIRED, &error)) { | |
| 336 RecordWriteResult(cache_type_, WRITE_RESULT_LAZY_CREATE_FAILURE); | |
| 337 Doom(); | |
| 338 *out_result = net::ERR_CACHE_WRITE_FAILURE; | |
| 339 return; | |
| 340 } | |
| 341 CreateEntryResult result; | |
| 342 if (!InitializeCreatedFile(file_index, &result)) { | |
| 343 RecordWriteResult(cache_type_, WRITE_RESULT_LAZY_INITIALIZE_FAILURE); | |
| 344 Doom(); | |
| 345 *out_result = net::ERR_CACHE_WRITE_FAILURE; | |
| 346 return; | |
| 347 } | |
| 348 } | |
| 349 DCHECK(!empty_file_omitted_[file_index]); | |
| 350 | |
| 351 if (extending_by_write) { | |
| 352 // The EOF record and the eventual stream afterward need to be zeroed out. | |
| 353 const int64 file_eof_offset = | |
| 354 out_entry_stat->GetEOFOffsetInFile(key_, index); | |
| 355 if (!files_[file_index].SetLength(file_eof_offset)) { | |
| 356 RecordWriteResult(cache_type_, WRITE_RESULT_PRETRUNCATE_FAILURE); | |
| 357 Doom(); | |
| 358 *out_result = net::ERR_CACHE_WRITE_FAILURE; | |
| 359 return; | |
| 360 } | |
| 361 } | |
| 362 if (buf_len > 0) { | |
| 363 if (files_[file_index].Write(file_offset, in_buf->data(), buf_len) != | |
| 364 buf_len) { | |
| 365 RecordWriteResult(cache_type_, WRITE_RESULT_WRITE_FAILURE); | |
| 366 Doom(); | |
| 367 *out_result = net::ERR_CACHE_WRITE_FAILURE; | |
| 368 return; | |
| 369 } | |
| 370 } | |
| 371 if (!truncate && (buf_len > 0 || !extending_by_write)) { | |
| 372 out_entry_stat->set_data_size( | |
| 373 index, std::max(out_entry_stat->data_size(index), offset + buf_len)); | |
| 374 } else { | |
| 375 out_entry_stat->set_data_size(index, offset + buf_len); | |
| 376 int file_eof_offset = out_entry_stat->GetLastEOFOffsetInFile(key_, index); | |
| 377 if (!files_[file_index].SetLength(file_eof_offset)) { | |
| 378 RecordWriteResult(cache_type_, WRITE_RESULT_TRUNCATE_FAILURE); | |
| 379 Doom(); | |
| 380 *out_result = net::ERR_CACHE_WRITE_FAILURE; | |
| 381 return; | |
| 382 } | |
| 383 } | |
| 384 | |
| 385 RecordWriteResult(cache_type_, WRITE_RESULT_SUCCESS); | |
| 386 base::Time modification_time = Time::Now(); | |
| 387 out_entry_stat->set_last_used(modification_time); | |
| 388 out_entry_stat->set_last_modified(modification_time); | |
| 389 *out_result = buf_len; | |
| 390 } | |
| 391 | |
| 392 void SimpleSynchronousEntry::ReadSparseData( | |
| 393 const EntryOperationData& in_entry_op, | |
| 394 net::IOBuffer* out_buf, | |
| 395 base::Time* out_last_used, | |
| 396 int* out_result) { | |
| 397 DCHECK(initialized_); | |
| 398 int64 offset = in_entry_op.sparse_offset; | |
| 399 int buf_len = in_entry_op.buf_len; | |
| 400 | |
| 401 char* buf = out_buf->data(); | |
| 402 int read_so_far = 0; | |
| 403 | |
| 404 // Find the first sparse range at or after the requested offset. | |
| 405 SparseRangeIterator it = sparse_ranges_.lower_bound(offset); | |
| 406 | |
| 407 if (it != sparse_ranges_.begin()) { | |
| 408 // Hop back one range and read the one overlapping with the start. | |
| 409 --it; | |
| 410 SparseRange* found_range = &it->second; | |
| 411 DCHECK_EQ(it->first, found_range->offset); | |
| 412 if (found_range->offset + found_range->length > offset) { | |
| 413 DCHECK_GE(found_range->length, 0); | |
| 414 DCHECK_LE(found_range->length, kint32max); | |
| 415 DCHECK_GE(offset - found_range->offset, 0); | |
| 416 DCHECK_LE(offset - found_range->offset, kint32max); | |
| 417 int net_offset = static_cast<int>(offset - found_range->offset); | |
| 418 int range_len_after_offset = | |
| 419 static_cast<int>(found_range->length - net_offset); | |
| 420 DCHECK_GE(range_len_after_offset, 0); | |
| 421 | |
| 422 int len_to_read = std::min(buf_len, range_len_after_offset); | |
| 423 if (!ReadSparseRange(found_range, net_offset, len_to_read, buf)) { | |
| 424 *out_result = net::ERR_CACHE_READ_FAILURE; | |
| 425 return; | |
| 426 } | |
| 427 read_so_far += len_to_read; | |
| 428 } | |
| 429 ++it; | |
| 430 } | |
| 431 | |
| 432 // Keep reading until the buffer is full or there is not another contiguous | |
| 433 // range. | |
| 434 while (read_so_far < buf_len && | |
| 435 it != sparse_ranges_.end() && | |
| 436 it->second.offset == offset + read_so_far) { | |
| 437 SparseRange* found_range = &it->second; | |
| 438 DCHECK_EQ(it->first, found_range->offset); | |
| 439 int range_len = base::saturated_cast<int>(found_range->length); | |
| 440 int len_to_read = std::min(buf_len - read_so_far, range_len); | |
| 441 if (!ReadSparseRange(found_range, 0, len_to_read, buf + read_so_far)) { | |
| 442 *out_result = net::ERR_CACHE_READ_FAILURE; | |
| 443 return; | |
| 444 } | |
| 445 read_so_far += len_to_read; | |
| 446 ++it; | |
| 447 } | |
| 448 | |
| 449 *out_result = read_so_far; | |
| 450 } | |
| 451 | |
| 452 void SimpleSynchronousEntry::WriteSparseData( | |
| 453 const EntryOperationData& in_entry_op, | |
| 454 net::IOBuffer* in_buf, | |
| 455 uint64 max_sparse_data_size, | |
| 456 SimpleEntryStat* out_entry_stat, | |
| 457 int* out_result) { | |
| 458 DCHECK(initialized_); | |
| 459 int64 offset = in_entry_op.sparse_offset; | |
| 460 int buf_len = in_entry_op.buf_len; | |
| 461 | |
| 462 const char* buf = in_buf->data(); | |
| 463 int written_so_far = 0; | |
| 464 int appended_so_far = 0; | |
| 465 | |
| 466 if (!sparse_file_open() && !CreateSparseFile()) { | |
| 467 *out_result = net::ERR_CACHE_WRITE_FAILURE; | |
| 468 return; | |
| 469 } | |
| 470 | |
| 471 uint64 sparse_data_size = out_entry_stat->sparse_data_size(); | |
| 472 // This is a pessimistic estimate; it assumes the entire buffer is going to | |
| 473 // be appended as a new range, not written over existing ranges. | |
| 474 if (sparse_data_size + buf_len > max_sparse_data_size) { | |
| 475 DVLOG(1) << "Truncating sparse data file (" << sparse_data_size << " + " | |
| 476 << buf_len << " > " << max_sparse_data_size << ")"; | |
| 477 TruncateSparseFile(); | |
| 478 } | |
| 479 | |
| 480 SparseRangeIterator it = sparse_ranges_.lower_bound(offset); | |
| 481 | |
| 482 if (it != sparse_ranges_.begin()) { | |
| 483 --it; | |
| 484 SparseRange* found_range = &it->second; | |
| 485 if (found_range->offset + found_range->length > offset) { | |
| 486 DCHECK_GE(found_range->length, 0); | |
| 487 DCHECK_LE(found_range->length, kint32max); | |
| 488 DCHECK_GE(offset - found_range->offset, 0); | |
| 489 DCHECK_LE(offset - found_range->offset, kint32max); | |
| 490 int net_offset = static_cast<int>(offset - found_range->offset); | |
| 491 int range_len_after_offset = | |
| 492 static_cast<int>(found_range->length - net_offset); | |
| 493 DCHECK_GE(range_len_after_offset, 0); | |
| 494 | |
| 495 int len_to_write = std::min(buf_len, range_len_after_offset); | |
| 496 if (!WriteSparseRange(found_range, net_offset, len_to_write, buf)) { | |
| 497 *out_result = net::ERR_CACHE_WRITE_FAILURE; | |
| 498 return; | |
| 499 } | |
| 500 written_so_far += len_to_write; | |
| 501 } | |
| 502 ++it; | |
| 503 } | |
| 504 | |
| 505 while (written_so_far < buf_len && | |
| 506 it != sparse_ranges_.end() && | |
| 507 it->second.offset < offset + buf_len) { | |
| 508 SparseRange* found_range = &it->second; | |
| 509 if (offset + written_so_far < found_range->offset) { | |
| 510 int len_to_append = | |
| 511 static_cast<int>(found_range->offset - (offset + written_so_far)); | |
| 512 if (!AppendSparseRange(offset + written_so_far, | |
| 513 len_to_append, | |
| 514 buf + written_so_far)) { | |
| 515 *out_result = net::ERR_CACHE_WRITE_FAILURE; | |
| 516 return; | |
| 517 } | |
| 518 written_so_far += len_to_append; | |
| 519 appended_so_far += len_to_append; | |
| 520 } | |
| 521 int range_len = base::saturated_cast<int>(found_range->length); | |
| 522 int len_to_write = std::min(buf_len - written_so_far, range_len); | |
| 523 if (!WriteSparseRange(found_range, | |
| 524 0, | |
| 525 len_to_write, | |
| 526 buf + written_so_far)) { | |
| 527 *out_result = net::ERR_CACHE_WRITE_FAILURE; | |
| 528 return; | |
| 529 } | |
| 530 written_so_far += len_to_write; | |
| 531 ++it; | |
| 532 } | |
| 533 | |
| 534 if (written_so_far < buf_len) { | |
| 535 int len_to_append = buf_len - written_so_far; | |
| 536 if (!AppendSparseRange(offset + written_so_far, | |
| 537 len_to_append, | |
| 538 buf + written_so_far)) { | |
| 539 *out_result = net::ERR_CACHE_WRITE_FAILURE; | |
| 540 return; | |
| 541 } | |
| 542 written_so_far += len_to_append; | |
| 543 appended_so_far += len_to_append; | |
| 544 } | |
| 545 | |
| 546 DCHECK_EQ(buf_len, written_so_far); | |
| 547 | |
| 548 base::Time modification_time = Time::Now(); | |
| 549 out_entry_stat->set_last_used(modification_time); | |
| 550 out_entry_stat->set_last_modified(modification_time); | |
| 551 int32 old_sparse_data_size = out_entry_stat->sparse_data_size(); | |
| 552 out_entry_stat->set_sparse_data_size(old_sparse_data_size + appended_so_far); | |
| 553 *out_result = written_so_far; | |
| 554 } | |
| 555 | |
| 556 void SimpleSynchronousEntry::GetAvailableRange( | |
| 557 const EntryOperationData& in_entry_op, | |
| 558 int64* out_start, | |
| 559 int* out_result) { | |
| 560 DCHECK(initialized_); | |
| 561 int64 offset = in_entry_op.sparse_offset; | |
| 562 int len = in_entry_op.buf_len; | |
| 563 | |
| 564 SparseRangeIterator it = sparse_ranges_.lower_bound(offset); | |
| 565 | |
| 566 int64 start = offset; | |
| 567 int64 avail_so_far = 0; | |
| 568 | |
| 569 if (it != sparse_ranges_.end() && it->second.offset < offset + len) | |
| 570 start = it->second.offset; | |
| 571 | |
| 572 if ((it == sparse_ranges_.end() || it->second.offset > offset) && | |
| 573 it != sparse_ranges_.begin()) { | |
| 574 --it; | |
| 575 if (it->second.offset + it->second.length > offset) { | |
| 576 start = offset; | |
| 577 avail_so_far = (it->second.offset + it->second.length) - offset; | |
| 578 } | |
| 579 ++it; | |
| 580 } | |
| 581 | |
| 582 while (start + avail_so_far < offset + len && | |
| 583 it != sparse_ranges_.end() && | |
| 584 it->second.offset == start + avail_so_far) { | |
| 585 avail_so_far += it->second.length; | |
| 586 ++it; | |
| 587 } | |
| 588 | |
| 589 int64 len_from_start = len - (start - offset); | |
| 590 *out_start = start; | |
| 591 *out_result = static_cast<int>(std::min(avail_so_far, len_from_start)); | |
| 592 } | |
| 593 | |
| 594 void SimpleSynchronousEntry::CheckEOFRecord(int index, | |
| 595 const SimpleEntryStat& entry_stat, | |
| 596 uint32 expected_crc32, | |
| 597 int* out_result) const { | |
| 598 DCHECK(initialized_); | |
| 599 uint32 crc32; | |
| 600 bool has_crc32; | |
| 601 int stream_size; | |
| 602 *out_result = | |
| 603 GetEOFRecordData(index, entry_stat, &has_crc32, &crc32, &stream_size); | |
| 604 if (*out_result != net::OK) { | |
| 605 Doom(); | |
| 606 return; | |
| 607 } | |
| 608 if (has_crc32 && crc32 != expected_crc32) { | |
| 609 DVLOG(1) << "EOF record had bad crc."; | |
| 610 *out_result = net::ERR_CACHE_CHECKSUM_MISMATCH; | |
| 611 RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_CRC_MISMATCH); | |
| 612 Doom(); | |
| 613 return; | |
| 614 } | |
| 615 RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_SUCCESS); | |
| 616 } | |
| 617 | |
| 618 void SimpleSynchronousEntry::Close( | |
| 619 const SimpleEntryStat& entry_stat, | |
| 620 scoped_ptr<std::vector<CRCRecord> > crc32s_to_write, | |
| 621 net::GrowableIOBuffer* stream_0_data) { | |
| 622 DCHECK(stream_0_data); | |
| 623 // Write stream 0 data. | |
| 624 int stream_0_offset = entry_stat.GetOffsetInFile(key_, 0, 0); | |
| 625 if (files_[0].Write(stream_0_offset, stream_0_data->data(), | |
| 626 entry_stat.data_size(0)) != | |
| 627 entry_stat.data_size(0)) { | |
| 628 RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE); | |
| 629 DVLOG(1) << "Could not write stream 0 data."; | |
| 630 Doom(); | |
| 631 } | |
| 632 | |
| 633 for (std::vector<CRCRecord>::const_iterator it = crc32s_to_write->begin(); | |
| 634 it != crc32s_to_write->end(); ++it) { | |
| 635 const int stream_index = it->index; | |
| 636 const int file_index = GetFileIndexFromStreamIndex(stream_index); | |
| 637 if (empty_file_omitted_[file_index]) | |
| 638 continue; | |
| 639 | |
| 640 SimpleFileEOF eof_record; | |
| 641 eof_record.stream_size = entry_stat.data_size(stream_index); | |
| 642 eof_record.final_magic_number = kSimpleFinalMagicNumber; | |
| 643 eof_record.flags = 0; | |
| 644 if (it->has_crc32) | |
| 645 eof_record.flags |= SimpleFileEOF::FLAG_HAS_CRC32; | |
| 646 eof_record.data_crc32 = it->data_crc32; | |
| 647 int eof_offset = entry_stat.GetEOFOffsetInFile(key_, stream_index); | |
| 648 // If stream 0 changed size, the file needs to be resized, otherwise the | |
| 649 // next open will yield wrong stream sizes. On stream 1 and stream 2 proper | |
| 650 // resizing of the file is handled in SimpleSynchronousEntry::WriteData(). | |
| 651 if (stream_index == 0 && | |
| 652 !files_[file_index].SetLength(eof_offset)) { | |
| 653 RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE); | |
| 654 DVLOG(1) << "Could not truncate stream 0 file."; | |
| 655 Doom(); | |
| 656 break; | |
| 657 } | |
| 658 if (files_[file_index].Write(eof_offset, | |
| 659 reinterpret_cast<const char*>(&eof_record), | |
| 660 sizeof(eof_record)) != | |
| 661 sizeof(eof_record)) { | |
| 662 RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE); | |
| 663 DVLOG(1) << "Could not write eof record."; | |
| 664 Doom(); | |
| 665 break; | |
| 666 } | |
| 667 } | |
| 668 for (int i = 0; i < kSimpleEntryFileCount; ++i) { | |
| 669 if (empty_file_omitted_[i]) | |
| 670 continue; | |
| 671 | |
| 672 files_[i].Close(); | |
| 673 const int64 file_size = entry_stat.GetFileSize(key_, i); | |
| 674 SIMPLE_CACHE_UMA(CUSTOM_COUNTS, | |
| 675 "LastClusterSize", cache_type_, | |
| 676 file_size % 4096, 0, 4097, 50); | |
| 677 const int64 cluster_loss = file_size % 4096 ? 4096 - file_size % 4096 : 0; | |
| 678 SIMPLE_CACHE_UMA(PERCENTAGE, | |
| 679 "LastClusterLossPercent", cache_type_, | |
| 680 static_cast<base::HistogramBase::Sample>( | |
| 681 cluster_loss * 100 / (cluster_loss + file_size))); | |
| 682 } | |
| 683 | |
| 684 if (sparse_file_open()) | |
| 685 sparse_file_.Close(); | |
| 686 | |
| 687 if (files_created_) { | |
| 688 const int stream2_file_index = GetFileIndexFromStreamIndex(2); | |
| 689 SIMPLE_CACHE_UMA(BOOLEAN, "EntryCreatedAndStream2Omitted", cache_type_, | |
| 690 empty_file_omitted_[stream2_file_index]); | |
| 691 } | |
| 692 RecordCloseResult(cache_type_, CLOSE_RESULT_SUCCESS); | |
| 693 have_open_files_ = false; | |
| 694 delete this; | |
| 695 } | |
| 696 | |
| 697 SimpleSynchronousEntry::SimpleSynchronousEntry(net::CacheType cache_type, | |
| 698 const FilePath& path, | |
| 699 const std::string& key, | |
| 700 const uint64 entry_hash) | |
| 701 : cache_type_(cache_type), | |
| 702 path_(path), | |
| 703 entry_hash_(entry_hash), | |
| 704 key_(key), | |
| 705 have_open_files_(false), | |
| 706 initialized_(false) { | |
| 707 for (int i = 0; i < kSimpleEntryFileCount; ++i) | |
| 708 empty_file_omitted_[i] = false; | |
| 709 } | |
| 710 | |
| 711 SimpleSynchronousEntry::~SimpleSynchronousEntry() { | |
| 712 DCHECK(!(have_open_files_ && initialized_)); | |
| 713 if (have_open_files_) | |
| 714 CloseFiles(); | |
| 715 } | |
| 716 | |
| 717 bool SimpleSynchronousEntry::MaybeOpenFile( | |
| 718 int file_index, | |
| 719 File::Error* out_error) { | |
| 720 DCHECK(out_error); | |
| 721 | |
| 722 FilePath filename = GetFilenameFromFileIndex(file_index); | |
| 723 int flags = File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE | | |
| 724 File::FLAG_SHARE_DELETE; | |
| 725 files_[file_index].Initialize(filename, flags); | |
| 726 *out_error = files_[file_index].error_details(); | |
| 727 | |
| 728 if (CanOmitEmptyFile(file_index) && !files_[file_index].IsValid() && | |
| 729 *out_error == File::FILE_ERROR_NOT_FOUND) { | |
| 730 empty_file_omitted_[file_index] = true; | |
| 731 return true; | |
| 732 } | |
| 733 | |
| 734 return files_[file_index].IsValid(); | |
| 735 } | |
| 736 | |
| 737 bool SimpleSynchronousEntry::MaybeCreateFile( | |
| 738 int file_index, | |
| 739 FileRequired file_required, | |
| 740 File::Error* out_error) { | |
| 741 DCHECK(out_error); | |
| 742 | |
| 743 if (CanOmitEmptyFile(file_index) && file_required == FILE_NOT_REQUIRED) { | |
| 744 empty_file_omitted_[file_index] = true; | |
| 745 return true; | |
| 746 } | |
| 747 | |
| 748 FilePath filename = GetFilenameFromFileIndex(file_index); | |
| 749 int flags = File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE | | |
| 750 File::FLAG_SHARE_DELETE; | |
| 751 files_[file_index].Initialize(filename, flags); | |
| 752 *out_error = files_[file_index].error_details(); | |
| 753 | |
| 754 empty_file_omitted_[file_index] = false; | |
| 755 | |
| 756 return files_[file_index].IsValid(); | |
| 757 } | |
| 758 | |
| 759 bool SimpleSynchronousEntry::OpenFiles( | |
| 760 bool had_index, | |
| 761 SimpleEntryStat* out_entry_stat) { | |
| 762 for (int i = 0; i < kSimpleEntryFileCount; ++i) { | |
| 763 File::Error error; | |
| 764 if (!MaybeOpenFile(i, &error)) { | |
| 765 // TODO(ttuttle,gavinp): Remove one each of these triplets of histograms. | |
| 766 // We can calculate the third as the sum or difference of the other two. | |
| 767 RecordSyncOpenResult( | |
| 768 cache_type_, OPEN_ENTRY_PLATFORM_FILE_ERROR, had_index); | |
| 769 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 770 "SyncOpenPlatformFileError", cache_type_, | |
| 771 -error, -base::File::FILE_ERROR_MAX); | |
| 772 if (had_index) { | |
| 773 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 774 "SyncOpenPlatformFileError_WithIndex", cache_type_, | |
| 775 -error, -base::File::FILE_ERROR_MAX); | |
| 776 } else { | |
| 777 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 778 "SyncOpenPlatformFileError_WithoutIndex", | |
| 779 cache_type_, | |
| 780 -error, -base::File::FILE_ERROR_MAX); | |
| 781 } | |
| 782 while (--i >= 0) | |
| 783 CloseFile(i); | |
| 784 return false; | |
| 785 } | |
| 786 } | |
| 787 | |
| 788 have_open_files_ = true; | |
| 789 | |
| 790 base::TimeDelta entry_age = base::Time::Now() - base::Time::UnixEpoch(); | |
| 791 for (int i = 0; i < kSimpleEntryFileCount; ++i) { | |
| 792 if (empty_file_omitted_[i]) { | |
| 793 out_entry_stat->set_data_size(i + 1, 0); | |
| 794 continue; | |
| 795 } | |
| 796 | |
| 797 File::Info file_info; | |
| 798 bool success = files_[i].GetInfo(&file_info); | |
| 799 base::Time file_last_modified; | |
| 800 if (!success) { | |
| 801 DLOG(WARNING) << "Could not get platform file info."; | |
| 802 continue; | |
| 803 } | |
| 804 out_entry_stat->set_last_used(file_info.last_accessed); | |
| 805 if (simple_util::GetMTime(path_, &file_last_modified)) | |
| 806 out_entry_stat->set_last_modified(file_last_modified); | |
| 807 else | |
| 808 out_entry_stat->set_last_modified(file_info.last_modified); | |
| 809 | |
| 810 base::TimeDelta stream_age = | |
| 811 base::Time::Now() - out_entry_stat->last_modified(); | |
| 812 if (stream_age < entry_age) | |
| 813 entry_age = stream_age; | |
| 814 | |
| 815 // Two things prevent from knowing the right values for |data_size|: | |
| 816 // 1) The key is not known, hence its length is unknown. | |
| 817 // 2) Stream 0 and stream 1 are in the same file, and the exact size for | |
| 818 // each will only be known when reading the EOF record for stream 0. | |
| 819 // | |
| 820 // The size for file 0 and 1 is temporarily kept in | |
| 821 // |data_size(1)| and |data_size(2)| respectively. Reading the key in | |
| 822 // InitializeForOpen yields the data size for each file. In the case of | |
| 823 // file hash_1, this is the total size of stream 2, and is assigned to | |
| 824 // data_size(2). In the case of file 0, it is the combined size of stream | |
| 825 // 0, stream 1 and one EOF record. The exact distribution of sizes between | |
| 826 // stream 1 and stream 0 is only determined after reading the EOF record | |
| 827 // for stream 0 in ReadAndValidateStream0. | |
| 828 out_entry_stat->set_data_size(i + 1, static_cast<int>(file_info.size)); | |
| 829 } | |
| 830 SIMPLE_CACHE_UMA(CUSTOM_COUNTS, | |
| 831 "SyncOpenEntryAge", cache_type_, | |
| 832 entry_age.InHours(), 1, 1000, 50); | |
| 833 | |
| 834 files_created_ = false; | |
| 835 | |
| 836 return true; | |
| 837 } | |
| 838 | |
| 839 bool SimpleSynchronousEntry::CreateFiles( | |
| 840 bool had_index, | |
| 841 SimpleEntryStat* out_entry_stat) { | |
| 842 for (int i = 0; i < kSimpleEntryFileCount; ++i) { | |
| 843 File::Error error; | |
| 844 if (!MaybeCreateFile(i, FILE_NOT_REQUIRED, &error)) { | |
| 845 // TODO(ttuttle,gavinp): Remove one each of these triplets of histograms. | |
| 846 // We can calculate the third as the sum or difference of the other two. | |
| 847 RecordSyncCreateResult(CREATE_ENTRY_PLATFORM_FILE_ERROR, had_index); | |
| 848 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 849 "SyncCreatePlatformFileError", cache_type_, | |
| 850 -error, -base::File::FILE_ERROR_MAX); | |
| 851 if (had_index) { | |
| 852 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 853 "SyncCreatePlatformFileError_WithIndex", cache_type_, | |
| 854 -error, -base::File::FILE_ERROR_MAX); | |
| 855 } else { | |
| 856 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 857 "SyncCreatePlatformFileError_WithoutIndex", | |
| 858 cache_type_, | |
| 859 -error, -base::File::FILE_ERROR_MAX); | |
| 860 } | |
| 861 while (--i >= 0) | |
| 862 CloseFile(i); | |
| 863 return false; | |
| 864 } | |
| 865 } | |
| 866 | |
| 867 have_open_files_ = true; | |
| 868 | |
| 869 base::Time creation_time = Time::Now(); | |
| 870 out_entry_stat->set_last_modified(creation_time); | |
| 871 out_entry_stat->set_last_used(creation_time); | |
| 872 for (int i = 0; i < kSimpleEntryStreamCount; ++i) | |
| 873 out_entry_stat->set_data_size(i, 0); | |
| 874 | |
| 875 files_created_ = true; | |
| 876 | |
| 877 return true; | |
| 878 } | |
| 879 | |
| 880 void SimpleSynchronousEntry::CloseFile(int index) { | |
| 881 if (empty_file_omitted_[index]) { | |
| 882 empty_file_omitted_[index] = false; | |
| 883 } else { | |
| 884 DCHECK(files_[index].IsValid()); | |
| 885 files_[index].Close(); | |
| 886 } | |
| 887 | |
| 888 if (sparse_file_open()) | |
| 889 CloseSparseFile(); | |
| 890 } | |
| 891 | |
| 892 void SimpleSynchronousEntry::CloseFiles() { | |
| 893 for (int i = 0; i < kSimpleEntryFileCount; ++i) | |
| 894 CloseFile(i); | |
| 895 } | |
| 896 | |
| 897 int SimpleSynchronousEntry::InitializeForOpen( | |
| 898 bool had_index, | |
| 899 SimpleEntryStat* out_entry_stat, | |
| 900 scoped_refptr<net::GrowableIOBuffer>* stream_0_data, | |
| 901 uint32* out_stream_0_crc32) { | |
| 902 DCHECK(!initialized_); | |
| 903 if (!OpenFiles(had_index, out_entry_stat)) { | |
| 904 DLOG(WARNING) << "Could not open platform files for entry."; | |
| 905 return net::ERR_FAILED; | |
| 906 } | |
| 907 for (int i = 0; i < kSimpleEntryFileCount; ++i) { | |
| 908 if (empty_file_omitted_[i]) | |
| 909 continue; | |
| 910 | |
| 911 SimpleFileHeader header; | |
| 912 int header_read_result = | |
| 913 files_[i].Read(0, reinterpret_cast<char*>(&header), sizeof(header)); | |
| 914 if (header_read_result != sizeof(header)) { | |
| 915 DLOG(WARNING) << "Cannot read header from entry."; | |
| 916 RecordSyncOpenResult(cache_type_, OPEN_ENTRY_CANT_READ_HEADER, had_index); | |
| 917 return net::ERR_FAILED; | |
| 918 } | |
| 919 | |
| 920 if (header.initial_magic_number != kSimpleInitialMagicNumber) { | |
| 921 // TODO(gavinp): This seems very bad; for now we log at WARNING, but we | |
| 922 // should give consideration to not saturating the log with these if that | |
| 923 // becomes a problem. | |
| 924 DLOG(WARNING) << "Magic number did not match."; | |
| 925 RecordSyncOpenResult(cache_type_, OPEN_ENTRY_BAD_MAGIC_NUMBER, had_index); | |
| 926 return net::ERR_FAILED; | |
| 927 } | |
| 928 | |
| 929 if (header.version != kSimpleEntryVersionOnDisk) { | |
| 930 DLOG(WARNING) << "Unreadable version."; | |
| 931 RecordSyncOpenResult(cache_type_, OPEN_ENTRY_BAD_VERSION, had_index); | |
| 932 return net::ERR_FAILED; | |
| 933 } | |
| 934 | |
| 935 scoped_ptr<char[]> key(new char[header.key_length]); | |
| 936 int key_read_result = files_[i].Read(sizeof(header), key.get(), | |
| 937 header.key_length); | |
| 938 if (key_read_result != implicit_cast<int>(header.key_length)) { | |
| 939 DLOG(WARNING) << "Cannot read key from entry."; | |
| 940 RecordSyncOpenResult(cache_type_, OPEN_ENTRY_CANT_READ_KEY, had_index); | |
| 941 return net::ERR_FAILED; | |
| 942 } | |
| 943 | |
| 944 key_ = std::string(key.get(), header.key_length); | |
| 945 if (i == 0) { | |
| 946 // File size for stream 0 has been stored temporarily in data_size[1]. | |
| 947 int total_data_size = | |
| 948 GetDataSizeFromKeyAndFileSize(key_, out_entry_stat->data_size(1)); | |
| 949 int ret_value_stream_0 = ReadAndValidateStream0( | |
| 950 total_data_size, out_entry_stat, stream_0_data, out_stream_0_crc32); | |
| 951 if (ret_value_stream_0 != net::OK) | |
| 952 return ret_value_stream_0; | |
| 953 } else { | |
| 954 out_entry_stat->set_data_size( | |
| 955 2, GetDataSizeFromKeyAndFileSize(key_, out_entry_stat->data_size(2))); | |
| 956 if (out_entry_stat->data_size(2) < 0) { | |
| 957 DLOG(WARNING) << "Stream 2 file is too small."; | |
| 958 return net::ERR_FAILED; | |
| 959 } | |
| 960 } | |
| 961 | |
| 962 if (base::Hash(key.get(), header.key_length) != header.key_hash) { | |
| 963 DLOG(WARNING) << "Hash mismatch on key."; | |
| 964 RecordSyncOpenResult( | |
| 965 cache_type_, OPEN_ENTRY_KEY_HASH_MISMATCH, had_index); | |
| 966 return net::ERR_FAILED; | |
| 967 } | |
| 968 } | |
| 969 | |
| 970 int32 sparse_data_size = 0; | |
| 971 if (!OpenSparseFileIfExists(&sparse_data_size)) { | |
| 972 RecordSyncOpenResult( | |
| 973 cache_type_, OPEN_ENTRY_SPARSE_OPEN_FAILED, had_index); | |
| 974 return net::ERR_FAILED; | |
| 975 } | |
| 976 out_entry_stat->set_sparse_data_size(sparse_data_size); | |
| 977 | |
| 978 bool removed_stream2 = false; | |
| 979 const int stream2_file_index = GetFileIndexFromStreamIndex(2); | |
| 980 DCHECK(CanOmitEmptyFile(stream2_file_index)); | |
| 981 if (!empty_file_omitted_[stream2_file_index] && | |
| 982 out_entry_stat->data_size(2) == 0) { | |
| 983 DVLOG(1) << "Removing empty stream 2 file."; | |
| 984 CloseFile(stream2_file_index); | |
| 985 DeleteFileForEntryHash(path_, entry_hash_, stream2_file_index); | |
| 986 empty_file_omitted_[stream2_file_index] = true; | |
| 987 removed_stream2 = true; | |
| 988 } | |
| 989 | |
| 990 SIMPLE_CACHE_UMA(BOOLEAN, "EntryOpenedAndStream2Removed", cache_type_, | |
| 991 removed_stream2); | |
| 992 | |
| 993 RecordSyncOpenResult(cache_type_, OPEN_ENTRY_SUCCESS, had_index); | |
| 994 initialized_ = true; | |
| 995 return net::OK; | |
| 996 } | |
| 997 | |
| 998 bool SimpleSynchronousEntry::InitializeCreatedFile( | |
| 999 int file_index, | |
| 1000 CreateEntryResult* out_result) { | |
| 1001 SimpleFileHeader header; | |
| 1002 header.initial_magic_number = kSimpleInitialMagicNumber; | |
| 1003 header.version = kSimpleEntryVersionOnDisk; | |
| 1004 | |
| 1005 header.key_length = key_.size(); | |
| 1006 header.key_hash = base::Hash(key_); | |
| 1007 | |
| 1008 int bytes_written = files_[file_index].Write( | |
| 1009 0, reinterpret_cast<char*>(&header), sizeof(header)); | |
| 1010 if (bytes_written != sizeof(header)) { | |
| 1011 *out_result = CREATE_ENTRY_CANT_WRITE_HEADER; | |
| 1012 return false; | |
| 1013 } | |
| 1014 | |
| 1015 bytes_written = files_[file_index].Write(sizeof(header), key_.data(), | |
| 1016 key_.size()); | |
| 1017 if (bytes_written != implicit_cast<int>(key_.size())) { | |
| 1018 *out_result = CREATE_ENTRY_CANT_WRITE_KEY; | |
| 1019 return false; | |
| 1020 } | |
| 1021 | |
| 1022 return true; | |
| 1023 } | |
| 1024 | |
| 1025 int SimpleSynchronousEntry::InitializeForCreate( | |
| 1026 bool had_index, | |
| 1027 SimpleEntryStat* out_entry_stat) { | |
| 1028 DCHECK(!initialized_); | |
| 1029 if (!CreateFiles(had_index, out_entry_stat)) { | |
| 1030 DLOG(WARNING) << "Could not create platform files."; | |
| 1031 return net::ERR_FILE_EXISTS; | |
| 1032 } | |
| 1033 for (int i = 0; i < kSimpleEntryFileCount; ++i) { | |
| 1034 if (empty_file_omitted_[i]) | |
| 1035 continue; | |
| 1036 | |
| 1037 CreateEntryResult result; | |
| 1038 if (!InitializeCreatedFile(i, &result)) { | |
| 1039 RecordSyncCreateResult(result, had_index); | |
| 1040 return net::ERR_FAILED; | |
| 1041 } | |
| 1042 } | |
| 1043 RecordSyncCreateResult(CREATE_ENTRY_SUCCESS, had_index); | |
| 1044 initialized_ = true; | |
| 1045 return net::OK; | |
| 1046 } | |
| 1047 | |
| 1048 int SimpleSynchronousEntry::ReadAndValidateStream0( | |
| 1049 int total_data_size, | |
| 1050 SimpleEntryStat* out_entry_stat, | |
| 1051 scoped_refptr<net::GrowableIOBuffer>* stream_0_data, | |
| 1052 uint32* out_stream_0_crc32) const { | |
| 1053 // Temporarily assign all the data size to stream 1 in order to read the | |
| 1054 // EOF record for stream 0, which contains the size of stream 0. | |
| 1055 out_entry_stat->set_data_size(0, 0); | |
| 1056 out_entry_stat->set_data_size(1, total_data_size - sizeof(SimpleFileEOF)); | |
| 1057 | |
| 1058 bool has_crc32; | |
| 1059 uint32 read_crc32; | |
| 1060 int stream_0_size; | |
| 1061 int ret_value_crc32 = GetEOFRecordData( | |
| 1062 0, *out_entry_stat, &has_crc32, &read_crc32, &stream_0_size); | |
| 1063 if (ret_value_crc32 != net::OK) | |
| 1064 return ret_value_crc32; | |
| 1065 | |
| 1066 if (stream_0_size > out_entry_stat->data_size(1)) | |
| 1067 return net::ERR_FAILED; | |
| 1068 | |
| 1069 // These are the real values of data size. | |
| 1070 out_entry_stat->set_data_size(0, stream_0_size); | |
| 1071 out_entry_stat->set_data_size( | |
| 1072 1, out_entry_stat->data_size(1) - stream_0_size); | |
| 1073 | |
| 1074 // Put stream 0 data in memory. | |
| 1075 *stream_0_data = new net::GrowableIOBuffer(); | |
| 1076 (*stream_0_data)->SetCapacity(stream_0_size); | |
| 1077 int file_offset = out_entry_stat->GetOffsetInFile(key_, 0, 0); | |
| 1078 File* file = const_cast<File*>(&files_[0]); | |
| 1079 int bytes_read = | |
| 1080 file->Read(file_offset, (*stream_0_data)->data(), stream_0_size); | |
| 1081 if (bytes_read != stream_0_size) | |
| 1082 return net::ERR_FAILED; | |
| 1083 | |
| 1084 // Check the CRC32. | |
| 1085 uint32 expected_crc32 = | |
| 1086 stream_0_size == 0 | |
| 1087 ? crc32(0, Z_NULL, 0) | |
| 1088 : crc32(crc32(0, Z_NULL, 0), | |
| 1089 reinterpret_cast<const Bytef*>((*stream_0_data)->data()), | |
| 1090 stream_0_size); | |
| 1091 if (has_crc32 && read_crc32 != expected_crc32) { | |
| 1092 DVLOG(1) << "EOF record had bad crc."; | |
| 1093 RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_CRC_MISMATCH); | |
| 1094 return net::ERR_FAILED; | |
| 1095 } | |
| 1096 *out_stream_0_crc32 = expected_crc32; | |
| 1097 RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_SUCCESS); | |
| 1098 return net::OK; | |
| 1099 } | |
| 1100 | |
| 1101 int SimpleSynchronousEntry::GetEOFRecordData(int index, | |
| 1102 const SimpleEntryStat& entry_stat, | |
| 1103 bool* out_has_crc32, | |
| 1104 uint32* out_crc32, | |
| 1105 int* out_data_size) const { | |
| 1106 SimpleFileEOF eof_record; | |
| 1107 int file_offset = entry_stat.GetEOFOffsetInFile(key_, index); | |
| 1108 int file_index = GetFileIndexFromStreamIndex(index); | |
| 1109 File* file = const_cast<File*>(&files_[file_index]); | |
| 1110 if (file->Read(file_offset, reinterpret_cast<char*>(&eof_record), | |
| 1111 sizeof(eof_record)) != | |
| 1112 sizeof(eof_record)) { | |
| 1113 RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_READ_FAILURE); | |
| 1114 return net::ERR_CACHE_CHECKSUM_READ_FAILURE; | |
| 1115 } | |
| 1116 | |
| 1117 if (eof_record.final_magic_number != kSimpleFinalMagicNumber) { | |
| 1118 RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_MAGIC_NUMBER_MISMATCH); | |
| 1119 DVLOG(1) << "EOF record had bad magic number."; | |
| 1120 return net::ERR_CACHE_CHECKSUM_READ_FAILURE; | |
| 1121 } | |
| 1122 | |
| 1123 *out_has_crc32 = (eof_record.flags & SimpleFileEOF::FLAG_HAS_CRC32) == | |
| 1124 SimpleFileEOF::FLAG_HAS_CRC32; | |
| 1125 *out_crc32 = eof_record.data_crc32; | |
| 1126 *out_data_size = eof_record.stream_size; | |
| 1127 SIMPLE_CACHE_UMA(BOOLEAN, "SyncCheckEOFHasCrc", cache_type_, *out_has_crc32); | |
| 1128 return net::OK; | |
| 1129 } | |
| 1130 | |
| 1131 void SimpleSynchronousEntry::Doom() const { | |
| 1132 DeleteFilesForEntryHash(path_, entry_hash_); | |
| 1133 } | |
| 1134 | |
| 1135 // static | |
| 1136 bool SimpleSynchronousEntry::DeleteFileForEntryHash( | |
| 1137 const FilePath& path, | |
| 1138 const uint64 entry_hash, | |
| 1139 const int file_index) { | |
| 1140 FilePath to_delete = path.AppendASCII( | |
| 1141 GetFilenameFromEntryHashAndFileIndex(entry_hash, file_index)); | |
| 1142 return simple_util::SimpleCacheDeleteFile(to_delete); | |
| 1143 } | |
| 1144 | |
| 1145 // static | |
| 1146 bool SimpleSynchronousEntry::DeleteFilesForEntryHash( | |
| 1147 const FilePath& path, | |
| 1148 const uint64 entry_hash) { | |
| 1149 bool result = true; | |
| 1150 for (int i = 0; i < kSimpleEntryFileCount; ++i) { | |
| 1151 if (!DeleteFileForEntryHash(path, entry_hash, i) && !CanOmitEmptyFile(i)) | |
| 1152 result = false; | |
| 1153 } | |
| 1154 FilePath to_delete = path.AppendASCII( | |
| 1155 GetSparseFilenameFromEntryHash(entry_hash)); | |
| 1156 simple_util::SimpleCacheDeleteFile(to_delete); | |
| 1157 return result; | |
| 1158 } | |
| 1159 | |
| 1160 void SimpleSynchronousEntry::RecordSyncCreateResult(CreateEntryResult result, | |
| 1161 bool had_index) { | |
| 1162 DCHECK_LT(result, CREATE_ENTRY_MAX); | |
| 1163 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 1164 "SyncCreateResult", cache_type_, result, CREATE_ENTRY_MAX); | |
| 1165 if (had_index) { | |
| 1166 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 1167 "SyncCreateResult_WithIndex", cache_type_, | |
| 1168 result, CREATE_ENTRY_MAX); | |
| 1169 } else { | |
| 1170 SIMPLE_CACHE_UMA(ENUMERATION, | |
| 1171 "SyncCreateResult_WithoutIndex", cache_type_, | |
| 1172 result, CREATE_ENTRY_MAX); | |
| 1173 } | |
| 1174 } | |
| 1175 | |
| 1176 FilePath SimpleSynchronousEntry::GetFilenameFromFileIndex(int file_index) { | |
| 1177 return path_.AppendASCII( | |
| 1178 GetFilenameFromEntryHashAndFileIndex(entry_hash_, file_index)); | |
| 1179 } | |
| 1180 | |
| 1181 bool SimpleSynchronousEntry::OpenSparseFileIfExists( | |
| 1182 int32* out_sparse_data_size) { | |
| 1183 DCHECK(!sparse_file_open()); | |
| 1184 | |
| 1185 FilePath filename = path_.AppendASCII( | |
| 1186 GetSparseFilenameFromEntryHash(entry_hash_)); | |
| 1187 int flags = File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE | | |
| 1188 File::FLAG_SHARE_DELETE; | |
| 1189 sparse_file_.Initialize(filename, flags); | |
| 1190 if (sparse_file_.IsValid()) | |
| 1191 return ScanSparseFile(out_sparse_data_size); | |
| 1192 | |
| 1193 return sparse_file_.error_details() == File::FILE_ERROR_NOT_FOUND; | |
| 1194 } | |
| 1195 | |
| 1196 bool SimpleSynchronousEntry::CreateSparseFile() { | |
| 1197 DCHECK(!sparse_file_open()); | |
| 1198 | |
| 1199 FilePath filename = path_.AppendASCII( | |
| 1200 GetSparseFilenameFromEntryHash(entry_hash_)); | |
| 1201 int flags = File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE | | |
| 1202 File::FLAG_SHARE_DELETE; | |
| 1203 sparse_file_.Initialize(filename, flags); | |
| 1204 if (!sparse_file_.IsValid()) | |
| 1205 return false; | |
| 1206 | |
| 1207 return InitializeSparseFile(); | |
| 1208 } | |
| 1209 | |
| 1210 void SimpleSynchronousEntry::CloseSparseFile() { | |
| 1211 DCHECK(sparse_file_open()); | |
| 1212 sparse_file_.Close(); | |
| 1213 } | |
| 1214 | |
| 1215 bool SimpleSynchronousEntry::TruncateSparseFile() { | |
| 1216 DCHECK(sparse_file_open()); | |
| 1217 | |
| 1218 int64 header_and_key_length = sizeof(SimpleFileHeader) + key_.size(); | |
| 1219 if (!sparse_file_.SetLength(header_and_key_length)) { | |
| 1220 DLOG(WARNING) << "Could not truncate sparse file"; | |
| 1221 return false; | |
| 1222 } | |
| 1223 | |
| 1224 sparse_ranges_.clear(); | |
| 1225 | |
| 1226 return true; | |
| 1227 } | |
| 1228 | |
| 1229 bool SimpleSynchronousEntry::InitializeSparseFile() { | |
| 1230 DCHECK(sparse_file_open()); | |
| 1231 | |
| 1232 SimpleFileHeader header; | |
| 1233 header.initial_magic_number = kSimpleInitialMagicNumber; | |
| 1234 header.version = kSimpleVersion; | |
| 1235 header.key_length = key_.size(); | |
| 1236 header.key_hash = base::Hash(key_); | |
| 1237 | |
| 1238 int header_write_result = | |
| 1239 sparse_file_.Write(0, reinterpret_cast<char*>(&header), sizeof(header)); | |
| 1240 if (header_write_result != sizeof(header)) { | |
| 1241 DLOG(WARNING) << "Could not write sparse file header"; | |
| 1242 return false; | |
| 1243 } | |
| 1244 | |
| 1245 int key_write_result = sparse_file_.Write(sizeof(header), key_.data(), | |
| 1246 key_.size()); | |
| 1247 if (key_write_result != implicit_cast<int>(key_.size())) { | |
| 1248 DLOG(WARNING) << "Could not write sparse file key"; | |
| 1249 return false; | |
| 1250 } | |
| 1251 | |
| 1252 sparse_ranges_.clear(); | |
| 1253 sparse_tail_offset_ = sizeof(header) + key_.size(); | |
| 1254 | |
| 1255 return true; | |
| 1256 } | |
| 1257 | |
| 1258 bool SimpleSynchronousEntry::ScanSparseFile(int32* out_sparse_data_size) { | |
| 1259 DCHECK(sparse_file_open()); | |
| 1260 | |
| 1261 int64 sparse_data_size = 0; | |
| 1262 | |
| 1263 SimpleFileHeader header; | |
| 1264 int header_read_result = | |
| 1265 sparse_file_.Read(0, reinterpret_cast<char*>(&header), sizeof(header)); | |
| 1266 if (header_read_result != sizeof(header)) { | |
| 1267 DLOG(WARNING) << "Could not read header from sparse file."; | |
| 1268 return false; | |
| 1269 } | |
| 1270 | |
| 1271 if (header.initial_magic_number != kSimpleInitialMagicNumber) { | |
| 1272 DLOG(WARNING) << "Sparse file magic number did not match."; | |
| 1273 return false; | |
| 1274 } | |
| 1275 | |
| 1276 if (header.version != kSimpleVersion) { | |
| 1277 DLOG(WARNING) << "Sparse file unreadable version."; | |
| 1278 return false; | |
| 1279 } | |
| 1280 | |
| 1281 sparse_ranges_.clear(); | |
| 1282 | |
| 1283 int64 range_header_offset = sizeof(header) + key_.size(); | |
| 1284 while (1) { | |
| 1285 SimpleFileSparseRangeHeader range_header; | |
| 1286 int range_header_read_result = | |
| 1287 sparse_file_.Read(range_header_offset, | |
| 1288 reinterpret_cast<char*>(&range_header), | |
| 1289 sizeof(range_header)); | |
| 1290 if (range_header_read_result == 0) | |
| 1291 break; | |
| 1292 if (range_header_read_result != sizeof(range_header)) { | |
| 1293 DLOG(WARNING) << "Could not read sparse range header."; | |
| 1294 return false; | |
| 1295 } | |
| 1296 | |
| 1297 if (range_header.sparse_range_magic_number != | |
| 1298 kSimpleSparseRangeMagicNumber) { | |
| 1299 DLOG(WARNING) << "Invalid sparse range header magic number."; | |
| 1300 return false; | |
| 1301 } | |
| 1302 | |
| 1303 SparseRange range; | |
| 1304 range.offset = range_header.offset; | |
| 1305 range.length = range_header.length; | |
| 1306 range.data_crc32 = range_header.data_crc32; | |
| 1307 range.file_offset = range_header_offset + sizeof(range_header); | |
| 1308 sparse_ranges_.insert(std::make_pair(range.offset, range)); | |
| 1309 | |
| 1310 range_header_offset += sizeof(range_header) + range.length; | |
| 1311 | |
| 1312 DCHECK_GE(sparse_data_size + range.length, sparse_data_size); | |
| 1313 sparse_data_size += range.length; | |
| 1314 } | |
| 1315 | |
| 1316 *out_sparse_data_size = static_cast<int32>(sparse_data_size); | |
| 1317 sparse_tail_offset_ = range_header_offset; | |
| 1318 | |
| 1319 return true; | |
| 1320 } | |
| 1321 | |
| 1322 bool SimpleSynchronousEntry::ReadSparseRange(const SparseRange* range, | |
| 1323 int offset, int len, char* buf) { | |
| 1324 DCHECK(range); | |
| 1325 DCHECK(buf); | |
| 1326 DCHECK_LE(offset, range->length); | |
| 1327 DCHECK_LE(offset + len, range->length); | |
| 1328 | |
| 1329 int bytes_read = sparse_file_.Read(range->file_offset + offset, buf, len); | |
| 1330 if (bytes_read < len) { | |
| 1331 DLOG(WARNING) << "Could not read sparse range."; | |
| 1332 return false; | |
| 1333 } | |
| 1334 | |
| 1335 // If we read the whole range and we have a crc32, check it. | |
| 1336 if (offset == 0 && len == range->length && range->data_crc32 != 0) { | |
| 1337 uint32 actual_crc32 = crc32(crc32(0L, Z_NULL, 0), | |
| 1338 reinterpret_cast<const Bytef*>(buf), | |
| 1339 len); | |
| 1340 if (actual_crc32 != range->data_crc32) { | |
| 1341 DLOG(WARNING) << "Sparse range crc32 mismatch."; | |
| 1342 return false; | |
| 1343 } | |
| 1344 } | |
| 1345 // TODO(ttuttle): Incremental crc32 calculation? | |
| 1346 | |
| 1347 return true; | |
| 1348 } | |
| 1349 | |
| 1350 bool SimpleSynchronousEntry::WriteSparseRange(SparseRange* range, | |
| 1351 int offset, int len, | |
| 1352 const char* buf) { | |
| 1353 DCHECK(range); | |
| 1354 DCHECK(buf); | |
| 1355 DCHECK_LE(offset, range->length); | |
| 1356 DCHECK_LE(offset + len, range->length); | |
| 1357 | |
| 1358 uint32 new_crc32 = 0; | |
| 1359 if (offset == 0 && len == range->length) { | |
| 1360 new_crc32 = crc32(crc32(0L, Z_NULL, 0), | |
| 1361 reinterpret_cast<const Bytef*>(buf), | |
| 1362 len); | |
| 1363 } | |
| 1364 | |
| 1365 if (new_crc32 != range->data_crc32) { | |
| 1366 range->data_crc32 = new_crc32; | |
| 1367 | |
| 1368 SimpleFileSparseRangeHeader header; | |
| 1369 header.sparse_range_magic_number = kSimpleSparseRangeMagicNumber; | |
| 1370 header.offset = range->offset; | |
| 1371 header.length = range->length; | |
| 1372 header.data_crc32 = range->data_crc32; | |
| 1373 | |
| 1374 int bytes_written = sparse_file_.Write(range->file_offset - sizeof(header), | |
| 1375 reinterpret_cast<char*>(&header), | |
| 1376 sizeof(header)); | |
| 1377 if (bytes_written != implicit_cast<int>(sizeof(header))) { | |
| 1378 DLOG(WARNING) << "Could not rewrite sparse range header."; | |
| 1379 return false; | |
| 1380 } | |
| 1381 } | |
| 1382 | |
| 1383 int bytes_written = sparse_file_.Write(range->file_offset + offset, buf, len); | |
| 1384 if (bytes_written < len) { | |
| 1385 DLOG(WARNING) << "Could not write sparse range."; | |
| 1386 return false; | |
| 1387 } | |
| 1388 | |
| 1389 return true; | |
| 1390 } | |
| 1391 | |
| 1392 bool SimpleSynchronousEntry::AppendSparseRange(int64 offset, | |
| 1393 int len, | |
| 1394 const char* buf) { | |
| 1395 DCHECK_GE(offset, 0); | |
| 1396 DCHECK_GT(len, 0); | |
| 1397 DCHECK(buf); | |
| 1398 | |
| 1399 uint32 data_crc32 = crc32(crc32(0L, Z_NULL, 0), | |
| 1400 reinterpret_cast<const Bytef*>(buf), | |
| 1401 len); | |
| 1402 | |
| 1403 SimpleFileSparseRangeHeader header; | |
| 1404 header.sparse_range_magic_number = kSimpleSparseRangeMagicNumber; | |
| 1405 header.offset = offset; | |
| 1406 header.length = len; | |
| 1407 header.data_crc32 = data_crc32; | |
| 1408 | |
| 1409 int bytes_written = sparse_file_.Write(sparse_tail_offset_, | |
| 1410 reinterpret_cast<char*>(&header), | |
| 1411 sizeof(header)); | |
| 1412 if (bytes_written != implicit_cast<int>(sizeof(header))) { | |
| 1413 DLOG(WARNING) << "Could not append sparse range header."; | |
| 1414 return false; | |
| 1415 } | |
| 1416 sparse_tail_offset_ += bytes_written; | |
| 1417 | |
| 1418 bytes_written = sparse_file_.Write(sparse_tail_offset_, buf, len); | |
| 1419 if (bytes_written < len) { | |
| 1420 DLOG(WARNING) << "Could not append sparse range data."; | |
| 1421 return false; | |
| 1422 } | |
| 1423 int64 data_file_offset = sparse_tail_offset_; | |
| 1424 sparse_tail_offset_ += bytes_written; | |
| 1425 | |
| 1426 SparseRange range; | |
| 1427 range.offset = offset; | |
| 1428 range.length = len; | |
| 1429 range.data_crc32 = data_crc32; | |
| 1430 range.file_offset = data_file_offset; | |
| 1431 sparse_ranges_.insert(std::make_pair(offset, range)); | |
| 1432 | |
| 1433 return true; | |
| 1434 } | |
| 1435 | |
| 1436 } // namespace disk_cache | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master