Disk cache: Add a hash to the entry's internal data.

net/disk_cache/disk_format.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The cache is stored on disk as a collection of block-files, plus an index
 // file plus a collection of external files.
 //
 // Any data blob bigger than kMaxBlockSize (net/addr.h) will be stored on a
 // separate file named f_xxx where x is a hexadecimal number. Shorter data will
 // be stored as a series of blocks on a block-file. In any case, CacheAddr
@@ skipping 105 matching lines @@
   CacheAddr   rankings_node;      // Rankings node for this entry.
   int32       reuse_count;        // How often is this entry used.
   int32       refetch_count;      // How often is this fetched from the net.
   int32       state;              // Current state.
   uint64      creation_time;
   int32       key_len;
   CacheAddr   long_key;           // Optional address of a long key.
   int32       data_size[4];       // We can store up to 4 data streams for each
   CacheAddr   data_addr[4];       // entry.
   uint32      flags;              // Any combination of EntryFlags.
-  int32       pad[5];
+  int32       pad[4];
+  uint32      self_hash;          // The hash of EntryStore up to this point.

[gavinp, 2011/11/29 15:47:42]

Why after the pad, and not before?  What do we expect the pad to usually be?  Is
it because if we later move values out of pad and into use, we'll end up with a
mid-structure self-hash, which would be too confusing?

[rvargas (doing something else), 2011/11/29 19:08:56]

Yes, that's it. Pad is set to zero, and the expected behavior is that we'll want
to verify that whatever we use it for is there. The only reason to not keep
going and hash the key is that we cannot have the hash in the middle of the
stuff that we are hashing (besides, there is already a hash of the key).

   char        key[256 - 24 * 4];  // null terminated
 };
 
 COMPILE_ASSERT(sizeof(EntryStore) == 256, bad_EntyStore);
 const int kMaxInternalKeyLength = 4 * sizeof(EntryStore) -
                                   offsetof(EntryStore, key) - 1;
 
 // Possible states for a given entry.
 enum EntryState {
   ENTRY_NORMAL = 0,
   ENTRY_EVICTED,    // The entry was recently evicted from the cache.
   ENTRY_DOOMED      // The entry was doomed.
 };
 
 // Flags that can be applied to an entry.
 enum EntryFlags {
   PARENT_ENTRY = 1,         // This entry has children (sparse) entries.
   CHILD_ENTRY = 1 << 1      // Child entry that stores sparse data.
 };
 
 #pragma pack(push, 4)
 // Rankings information for a given entry.
 struct RankingsNode {
   uint64      last_used;        // LRU info.
   uint64      last_modified;    // LRU info.
   CacheAddr   next;             // LRU list.
   CacheAddr   prev;             // LRU list.
   CacheAddr   contents;         // Address of the EntryStore.
   int32       dirty;            // The entry is being modifyied.
-  int32       dummy;            // Old files may have a pointer here.
+  uint32      self_hash;        // RankingsNode's hash.
 };
 #pragma pack(pop)
 
 COMPILE_ASSERT(sizeof(RankingsNode) == 36, bad_RankingsNode);
 
 const uint32 kBlockMagic = 0xC104CAC3;
 const int kBlockHeaderSize = 8192;  // Two pages: almost 64k entries
 const int kMaxBlocks = (kBlockHeaderSize - 80) * 8;
 
 // Bitmap to track used blocks on a block-file.
@@ skipping 86 matching lines @@
 };
 
 // The number of blocks stored by a child entry.
 const int kNumSparseBits = 1024;
 COMPILE_ASSERT(sizeof(SparseData) == sizeof(SparseHeader) + kNumSparseBits / 8,
                Invalid_SparseData_bitmap);
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_DISK_FORMAT_H_