1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
// Copyright (c) 2006-2008 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.
// See net/disk_cache/disk_cache.h for the public interface of the cache.
#ifndef NET_DISK_CACHE_BACKEND_IMPL_H__
#define NET_DISK_CACHE_BACKEND_IMPL_H__
#include "base/compiler_specific.h"
#include "base/timer.h"
#include "net/disk_cache/block_files.h"
#include "net/disk_cache/disk_cache.h"
#include "net/disk_cache/rankings.h"
#include "net/disk_cache/stats.h"
#include "net/disk_cache/trace.h"
namespace disk_cache {
// This class implements the Backend interface. An object of this
// class handles the operations of the cache for a particular profile.
class BackendImpl : public Backend {
public:
explicit BackendImpl(const std::wstring& path)
: path_(path), block_files_(path), mask_(0), max_size_(0),
init_(false), restarted_(false), unit_test_(false), read_only_(false),
ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {}
// mask can be used to limit the usable size of the hash table, for testing.
BackendImpl(const std::wstring& path, uint32 mask)
: path_(path), block_files_(path), mask_(mask), max_size_(0),
init_(false), restarted_(false), unit_test_(false), read_only_(false),
ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {}
~BackendImpl();
// Performs general initialization for this current instance of the cache.
bool Init();
// Backend interface.
virtual int32 GetEntryCount() const;
virtual bool OpenEntry(const std::string& key, Entry** entry);
virtual bool CreateEntry(const std::string& key, Entry** entry);
virtual bool DoomEntry(const std::string& key);
virtual bool DoomAllEntries();
virtual bool DoomEntriesBetween(const base::Time initial_time,
const base::Time end_time);
virtual bool DoomEntriesSince(const base::Time initial_time);
virtual bool OpenNextEntry(void** iter, Entry** next_entry);
virtual void EndEnumeration(void** iter);
virtual void GetStats(StatsItems* stats);
// Sets the maximum size for the total amount of data stored by this instance.
bool SetMaxSize(int max_bytes);
// Returns the full name for an external storage file.
std::wstring GetFileName(Addr address) const;
// Returns the actual file used to store a given (non-external) address.
MappedFile* File(Addr address);
// Creates an external storage file.
bool CreateExternalFile(Addr* address);
// Creates a new storage block of size block_count.
bool CreateBlock(FileType block_type, int block_count,
Addr* block_address);
// Deletes a given storage block. deep set to true can be used to zero-fill
// the related storage in addition of releasing the related block.
void DeleteBlock(Addr block_address, bool deep);
// Updates the ranking information for an entry.
void UpdateRank(CacheRankingsBlock* node, bool modified);
// A node was recovered from a crash, it may not be on the index, so this
// method checks it and takes the appropriate action.
void RecoveredEntry(CacheRankingsBlock* rankings);
// Permanently deletes an entry.
void InternalDoomEntry(EntryImpl* entry);
// This method must be called whenever an entry is released for the last time.
void CacheEntryDestroyed();
// Returns the id being used on this run of the cache.
int32 GetCurrentEntryId();
// Returns the maximum size for a file to reside on the cache.
int MaxFileSize() const;
// A user data block is being created, extended or truncated.
void ModifyStorageSize(int32 old_size, int32 new_size);
// Logs requests that are denied due to being too big.
void TooMuchStorageRequested(int32 size);
// Reports a critical error (and disables the cache).
void CriticalError(int error);
// Called when an interesting event should be logged (counted).
void OnEvent(Stats::Counters an_event);
// Timer callback to calculate usage statistics.
void OnStatsTimer();
// Handles the pending asynchronous IO count.
void IncrementIoCount();
void DecrementIoCount();
// Sets internal parameters to enable unit testing mode.
void SetUnitTestMode();
// Sets internal parameters to enable upgrade mode (for internal tools).
void SetUpgradeMode();
// Clears the counter of references to test handling of corruptions.
void ClearRefCountForTest();
// Peforms a simple self-check, and returns the number of dirty items
// or an error code (negative value).
int SelfCheck();
// Same bahavior as OpenNextEntry but walks the list from back to front.
bool OpenPrevEntry(void** iter, Entry** prev_entry);
private:
// Creates a new backing file for the cache index.
bool CreateBackingStore(disk_cache::File* file);
bool InitBackingStore(bool* file_created);
void AdjustMaxCacheSize(int table_len);
// Deletes the cache and starts again.
void RestartCache();
// Creates a new entry object and checks to see if it is dirty. Returns zero
// on success, or a disk_cache error on failure.
int NewEntry(Addr address, EntryImpl** entry, bool* dirty);
// Returns a given entry from the cache. The entry to match is determined by
// key and hash, and the returned entry may be the matched one or it's parent
// on the list of entries with the same hash (or bucket).
EntryImpl* MatchEntry(const std::string& key, uint32 hash,
bool find_parent);
// Opens the next or previous entry on a cache iteration.
bool OpenFollowingEntry(bool forward, void** iter, Entry** next_entry);
void DestroyInvalidEntry(Addr address, EntryImpl* entry);
// Deletes entries from the cache until the current size is below the limit.
// If empty is true, the whole cache will be trimmed, regardless of being in
// use.
void TrimCache(bool empty);
// Handles the used storage count.
void AddStorageSize(int32 bytes);
void SubstractStorageSize(int32 bytes);
// Update the number of referenced cache entries.
void IncreaseNumRefs();
void DecreaseNumRefs();
// Dumps current cache statistics to the log.
void LogStats();
// Performs basic checks on the index file. Returns false on failure.
bool CheckIndex();
// Part of the selt test. Returns the number or dirty entries, or an error.
int CheckAllEntries();
// Part of the self test. Returns false if the entry is corrupt.
bool CheckEntry(EntryImpl* cache_entry);
scoped_refptr<MappedFile> index_; // The main cache index.
std::wstring path_; // Path to the folder used as backing storage.
Index* data_; // Pointer to the index data.
BlockFiles block_files_; // Set of files used to store all data.
Rankings rankings_; // Rankings to be able to trim the cache.
uint32 mask_; // Binary mask to map a hash to the hash table.
int32 max_size_; // Maximum data size for this instance.
int num_refs_; // Number of referenced cache entries.
int max_refs_; // Max number of eferenced cache entries.
int num_pending_io_; // Number of pending IO operations;
bool init_; // controls the initialization of the system.
bool restarted_;
bool unit_test_;
bool read_only_; // Prevents updates of the rankings data (used by tools).
bool disabled_;
Stats stats_; // Usage statistcs.
base::RepeatingTimer<BackendImpl> timer_; // Usage timer.
TraceObject trace_object_; // Inits and destroys internal tracing.
ScopedRunnableMethodFactory<BackendImpl> factory_;
DISALLOW_EVIL_CONSTRUCTORS(BackendImpl);
};
} // namespace disk_cache
#endif // NET_DISK_CACHE_BACKEND_IMPL_H__
|
