net/disk_cache/simple/simple_synchronous_entry.h

   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 #ifndef NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_
   6 #define NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_
   7
   8 #include <algorithm>
   9 #include <map>
  10 #include <string>
  11 #include <utility>
  12 #include <vector>
  13
  14 #include "base/files/file.h"
  15 #include "base/files/file_path.h"
  16 #include "base/memory/ref_counted.h"
  17 #include "base/memory/scoped_ptr.h"
  18 #include "base/time/time.h"
  19 #include "net/base/cache_type.h"
  20 #include "net/base/net_export.h"
  21 #include "net/disk_cache/simple/simple_entry_format.h"
  22
  23 namespace net {
  24 class GrowableIOBuffer;
  25 class IOBuffer;
  26 }
  27
  28 namespace disk_cache {
  29
  30 class SimpleSynchronousEntry;
  31
  32 // This class handles the passing of data about the entry between
  33 // SimpleEntryImplementation and SimpleSynchronousEntry and the computation of
  34 // file offsets based on the data size for all streams.
  35 class NET_EXPORT_PRIVATE SimpleEntryStat {
  36  public:
  37   SimpleEntryStat(base::Time last_used,
  38                   base::Time last_modified,
  39                   const int32 data_size[],
  40                   const int32 sparse_data_size);
  41
  42   int GetOffsetInFile(const std::string& key,
  43                       int offset,
  44                       int stream_index) const;
  45   int GetEOFOffsetInFile(const std::string& key, int stream_index) const;
  46   int GetLastEOFOffsetInFile(const std::string& key, int file_index) const;
  47   int GetFileSize(const std::string& key, int file_index) const;
  48
  49   base::Time last_used() const { return last_used_; }
  50   base::Time last_modified() const { return last_modified_; }
  51   void set_last_used(base::Time last_used) { last_used_ = last_used; }
  52   void set_last_modified(base::Time last_modified) {
  53     last_modified_ = last_modified;
  54   }
  55
  56   int32 data_size(int stream_index) const { return data_size_[stream_index]; }
  57   void set_data_size(int stream_index, int data_size) {
  58     data_size_[stream_index] = data_size;
  59   }
  60
  61   int32 sparse_data_size() const { return sparse_data_size_; }
  62   void set_sparse_data_size(int32 sparse_data_size) {
  63     sparse_data_size_ = sparse_data_size;
  64   }
  65
  66  private:
  67   base::Time last_used_;
  68   base::Time last_modified_;
  69   int32 data_size_[kSimpleEntryStreamCount];
  70   int32 sparse_data_size_;
  71 };
  72
  73 struct SimpleEntryCreationResults {
  74   explicit SimpleEntryCreationResults(SimpleEntryStat entry_stat);
  75   ~SimpleEntryCreationResults();
  76
  77   SimpleSynchronousEntry* sync_entry;
  78   scoped_refptr<net::GrowableIOBuffer> stream_0_data;
  79   SimpleEntryStat entry_stat;
  80   uint32 stream_0_crc32;
  81   int result;
  82 };
  83
  84 // Worker thread interface to the very simple cache. This interface is not
  85 // thread safe, and callers must ensure that it is only ever accessed from
  86 // a single thread between synchronization points.
  87 class SimpleSynchronousEntry {
  88  public:
  89   struct CRCRecord {
  90     CRCRecord();
  91     CRCRecord(int index_p, bool has_crc32_p, uint32 data_crc32_p);
  92
  93     int index;
  94     bool has_crc32;
  95     uint32 data_crc32;
  96   };
  97
  98   struct EntryOperationData {
  99     EntryOperationData(int index_p, int offset_p, int buf_len_p);
 100     EntryOperationData(int index_p,
 101                        int offset_p,
 102                        int buf_len_p,
 103                        bool truncate_p,
 104                        bool doomed_p);
 105     EntryOperationData(int64 sparse_offset_p, int buf_len_p);
 106
 107     int index;
 108     int offset;
 109     int64 sparse_offset;
 110     int buf_len;
 111     bool truncate;
 112     bool doomed;
 113   };
 114
 115   static void OpenEntry(net::CacheType cache_type,
 116                         const base::FilePath& path,
 117                         uint64 entry_hash,
 118                         bool had_index,
 119                         SimpleEntryCreationResults* out_results);
 120
 121   static void CreateEntry(net::CacheType cache_type,
 122                           const base::FilePath& path,
 123                           const std::string& key,
 124                           uint64 entry_hash,
 125                           bool had_index,
 126                           SimpleEntryCreationResults* out_results);
 127
 128   // Deletes an entry from the file system without affecting the state of the
 129   // corresponding instance, if any (allowing operations to continue to be
 130   // executed through that instance). Returns a net error code.
 131   static int DoomEntry(const base::FilePath& path,
 132                        uint64 entry_hash);
 133
 134   // Like |DoomEntry()| above. Deletes all entries corresponding to the
 135   // |key_hashes|. Succeeds only when all entries are deleted. Returns a net
 136   // error code.
 137   static int DoomEntrySet(const std::vector<uint64>* key_hashes,
 138                           const base::FilePath& path);
 139
 140   // N.B. ReadData(), WriteData(), CheckEOFRecord() and Close() may block on IO.
 141   void ReadData(const EntryOperationData& in_entry_op,
 142                 net::IOBuffer* out_buf,
 143                 uint32* out_crc32,
 144                 SimpleEntryStat* entry_stat,
 145                 int* out_result) const;
 146   void WriteData(const EntryOperationData& in_entry_op,
 147                  net::IOBuffer* in_buf,
 148                  SimpleEntryStat* out_entry_stat,
 149                  int* out_result);
 150   void CheckEOFRecord(int index,
 151                       const SimpleEntryStat& entry_stat,
 152                       uint32 expected_crc32,
 153                       int* out_result) const;
 154
 155   void ReadSparseData(const EntryOperationData& in_entry_op,
 156                       net::IOBuffer* out_buf,
 157                       base::Time* out_last_used,
 158                       int* out_result);
 159   void WriteSparseData(const EntryOperationData& in_entry_op,
 160                        net::IOBuffer* in_buf,
 161                        int64 max_sparse_data_size,
 162                        SimpleEntryStat* out_entry_stat,
 163                        int* out_result);
 164   void GetAvailableRange(const EntryOperationData& in_entry_op,
 165                          int64* out_start,
 166                          int* out_result);
 167
 168   // Close all streams, and add write EOF records to streams indicated by the
 169   // CRCRecord entries in |crc32s_to_write|.
 170   void Close(const SimpleEntryStat& entry_stat,
 171              scoped_ptr<std::vector<CRCRecord> > crc32s_to_write,
 172              net::GrowableIOBuffer* stream_0_data);
 173
 174   const base::FilePath& path() const { return path_; }
 175   std::string key() const { return key_; }
 176
 177  private:
 178   enum CreateEntryResult {
 179     CREATE_ENTRY_SUCCESS = 0,
 180     CREATE_ENTRY_PLATFORM_FILE_ERROR = 1,
 181     CREATE_ENTRY_CANT_WRITE_HEADER = 2,
 182     CREATE_ENTRY_CANT_WRITE_KEY = 3,
 183     CREATE_ENTRY_MAX = 4,
 184   };
 185
 186   enum FileRequired {
 187     FILE_NOT_REQUIRED,
 188     FILE_REQUIRED
 189   };
 190
 191   struct SparseRange {
 192     int64 offset;
 193     int64 length;
 194     uint32 data_crc32;
 195     int64 file_offset;
 196
 197     bool operator<(const SparseRange& other) const {
 198       return offset < other.offset;
 199     }
 200   };
 201
 202   SimpleSynchronousEntry(
 203       net::CacheType cache_type,
 204       const base::FilePath& path,
 205       const std::string& key,
 206       uint64 entry_hash);
 207
 208   // Like Entry, the SimpleSynchronousEntry self releases when Close() is
 209   // called.
 210   ~SimpleSynchronousEntry();
 211
 212   // Tries to open one of the cache entry files. Succeeds if the open succeeds
 213   // or if the file was not found and is allowed to be omitted if the
 214   // corresponding stream is empty.
 215   bool MaybeOpenFile(int file_index,
 216                      base::File::Error* out_error);
 217   // Creates one of the cache entry files if necessary. If the file is allowed
 218   // to be omitted if the corresponding stream is empty, and if |file_required|
 219   // is FILE_NOT_REQUIRED, then the file is not created; otherwise, it is.
 220   bool MaybeCreateFile(int file_index,
 221                        FileRequired file_required,
 222                        base::File::Error* out_error);
 223   bool OpenFiles(bool had_index,
 224                  SimpleEntryStat* out_entry_stat);
 225   bool CreateFiles(bool had_index,
 226                    SimpleEntryStat* out_entry_stat);
 227   void CloseFile(int index);
 228   void CloseFiles();
 229
 230   // Returns a net error, i.e. net::OK on success. |had_index| is passed
 231   // from the main entry for metrics purposes, and is true if the index was
 232   // initialized when the open operation began.
 233   int InitializeForOpen(bool had_index,
 234                         SimpleEntryStat* out_entry_stat,
 235                         scoped_refptr<net::GrowableIOBuffer>* stream_0_data,
 236                         uint32* out_stream_0_crc32);
 237
 238   // Writes the header and key to a newly-created stream file. |index| is the
 239   // index of the stream. Returns true on success; returns false and sets
 240   // |*out_result| on failure.
 241   bool InitializeCreatedFile(int index, CreateEntryResult* out_result);
 242
 243   // Returns a net error, including net::OK on success and net::FILE_EXISTS
 244   // when the entry already exists. |had_index| is passed from the main entry
 245   // for metrics purposes, and is true if the index was initialized when the
 246   // create operation began.
 247   int InitializeForCreate(bool had_index, SimpleEntryStat* out_entry_stat);
 248
 249   // Allocates and fills a buffer with stream 0 data in |stream_0_data|, then
 250   // checks its crc32.
 251   int ReadAndValidateStream0(
 252       int total_data_size,
 253       SimpleEntryStat* out_entry_stat,
 254       scoped_refptr<net::GrowableIOBuffer>* stream_0_data,
 255       uint32* out_stream_0_crc32) const;
 256
 257   int GetEOFRecordData(int index,
 258                        const SimpleEntryStat& entry_stat,
 259                        bool* out_has_crc32,
 260                        uint32* out_crc32,
 261                        int* out_data_size) const;
 262   void Doom() const;
 263
 264   // Opens the sparse data file and scans it if it exists.
 265   bool OpenSparseFileIfExists(int32* out_sparse_data_size);
 266
 267   // Creates and initializes the sparse data file.
 268   bool CreateSparseFile();
 269
 270   // Closes the sparse data file.
 271   void CloseSparseFile();
 272
 273   // Writes the header to the (newly-created) sparse file.
 274   bool InitializeSparseFile();
 275
 276   // Removes all but the header of the sparse file.
 277   bool TruncateSparseFile();
 278
 279   // Scans the existing ranges in the sparse file. Populates |sparse_ranges_|
 280   // and sets |*out_sparse_data_size| to the total size of all the ranges (not
 281   // including headers).
 282   bool ScanSparseFile(int32* out_sparse_data_size);
 283
 284   // Reads from a single sparse range. If asked to read the entire range, also
 285   // verifies the CRC32.
 286   bool ReadSparseRange(const SparseRange* range,
 287                        int offset, int len, char* buf);
 288
 289   // Writes to a single (existing) sparse range. If asked to write the entire
 290   // range, also updates the CRC32; otherwise, invalidates it.
 291   bool WriteSparseRange(SparseRange* range,
 292                         int offset, int len, const char* buf);
 293
 294   // Appends a new sparse range to the sparse data file.
 295   bool AppendSparseRange(int64 offset, int len, const char* buf);
 296
 297   static bool DeleteFileForEntryHash(const base::FilePath& path,
 298                                      uint64 entry_hash,
 299                                      int file_index);
 300   static bool DeleteFilesForEntryHash(const base::FilePath& path,
 301                                       uint64 entry_hash);
 302
 303   void RecordSyncCreateResult(CreateEntryResult result, bool had_index);
 304
 305   base::FilePath GetFilenameFromFileIndex(int file_index);
 306
 307   bool sparse_file_open() const {
 308     return sparse_file_.IsValid();
 309   }
 310
 311   const net::CacheType cache_type_;
 312   const base::FilePath path_;
 313   const uint64 entry_hash_;
 314   std::string key_;
 315
 316   bool have_open_files_;
 317   bool initialized_;
 318
 319   base::File files_[kSimpleEntryFileCount];
 320
 321   // True if the corresponding stream is empty and therefore no on-disk file
 322   // was created to store it.
 323   bool empty_file_omitted_[kSimpleEntryFileCount];
 324
 325   typedef std::map<int64, SparseRange> SparseRangeOffsetMap;
 326   typedef SparseRangeOffsetMap::iterator SparseRangeIterator;
 327   SparseRangeOffsetMap sparse_ranges_;
 328   base::File sparse_file_;
 329   // Offset of the end of the sparse file (where the next sparse range will be
 330   // written).
 331   int64 sparse_tail_offset_;
 332
 333   // True if the entry was created, or false if it was opened. Used to log
 334   // SimpleCache.*.EntryCreatedWithStream2Omitted only for created entries.
 335   bool files_created_;
 336 };
 337
 338 }  // namespace disk_cache
 339
 340 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_