]>
Commit | Line | Data |
---|---|---|
9487bae9 | 1 | /* |
ef57eb7b | 2 | * Copyright (C) 1996-2016 The Squid Software Foundation and contributors |
9487bae9 | 3 | * |
bbc27441 AJ |
4 | * Squid software is distributed under GPLv2+ license and includes |
5 | * contributions from numerous individuals and organizations. | |
6 | * Please see the COPYING and CONTRIBUTORS files for details. | |
9487bae9 AR |
7 | */ |
8 | ||
bbc27441 AJ |
9 | /* DEBUG: section 20 Memory Cache */ |
10 | ||
f7f3304a | 11 | #include "squid.h" |
a4555399 | 12 | #include "base/RunnersRegistry.h" |
ce49546e | 13 | #include "CollapsedForwarding.h" |
582c2af2 | 14 | #include "HttpReply.h" |
9487bae9 AR |
15 | #include "ipc/mem/Page.h" |
16 | #include "ipc/mem/Pages.h" | |
17 | #include "MemObject.h" | |
18 | #include "MemStore.h" | |
b6149797 | 19 | #include "mime_header.h" |
4d5904f7 | 20 | #include "SquidConfig.h" |
06684a9b | 21 | #include "SquidMath.h" |
93bc1434 | 22 | #include "StoreStats.h" |
5bed43d6 | 23 | #include "tools.h" |
9487bae9 | 24 | |
a4555399 | 25 | /// shared memory segment path to use for MemStore maps |
1860fbac | 26 | static const SBuf MapLabel("cache_mem_map"); |
06684a9b AR |
27 | /// shared memory segment path to use for the free slices index |
28 | static const char *SpaceLabel = "cache_mem_space"; | |
1860fbac AR |
29 | /// shared memory segment path to use for IDs of shared pages with slice data |
30 | static const char *ExtrasLabel = "cache_mem_ex"; | |
06684a9b | 31 | // TODO: sync with Rock::SwapDir::*Path() |
9487bae9 | 32 | |
06684a9b AR |
33 | // We store free slot IDs (i.e., "space") as Page objects so that we can use |
34 | // Ipc::Mem::PageStack. Pages require pool IDs. The value here is not really | |
35 | // used except for a positivity test. A unique value is handy for debugging. | |
36 | static const uint32_t SpacePoolId = 510716; | |
9487bae9 | 37 | |
abf396ec AR |
38 | /// Packs to shared memory, allocating new slots/pages as needed. |
39 | /// Requires an Ipc::StoreMapAnchor locked for writing. | |
40 | class ShmWriter: public Packable | |
41 | { | |
42 | public: | |
43 | ShmWriter(MemStore &aStore, StoreEntry *anEntry, const sfileno aFileNo, Ipc::StoreMapSliceId aFirstSlice = -1); | |
44 | ||
45 | /* Packable API */ | |
46 | virtual void append(const char *aBuf, int aSize) override; | |
47 | virtual void vappendf(const char *fmt, va_list ap) override; | |
48 | ||
49 | public: | |
50 | StoreEntry *entry; ///< the entry being updated | |
51 | ||
52 | /// the slot keeping the first byte of the appended content (at least) | |
53 | /// either set via constructor parameter or allocated by the first append | |
54 | Ipc::StoreMapSliceId firstSlice; | |
55 | ||
56 | /// the slot keeping the last byte of the appended content (at least) | |
57 | Ipc::StoreMapSliceId lastSlice; | |
58 | ||
59 | uint64_t totalWritten; ///< cumulative number of bytes appended so far | |
60 | ||
61 | protected: | |
62 | void copyToShm(); | |
63 | void copyToShmSlice(Ipc::StoreMap::Slice &slice); | |
64 | ||
65 | private: | |
66 | MemStore &store; | |
67 | const sfileno fileNo; | |
68 | ||
69 | /* set by (and only valid during) append calls */ | |
70 | const char *buf; ///< content being appended now | |
71 | int bufSize; ///< buf size | |
72 | int bufWritten; ///< buf bytes appended so far | |
73 | }; | |
74 | ||
75 | /* ShmWriter */ | |
76 | ||
77 | ShmWriter::ShmWriter(MemStore &aStore, StoreEntry *anEntry, const sfileno aFileNo, Ipc::StoreMapSliceId aFirstSlice): | |
78 | entry(anEntry), | |
79 | firstSlice(aFirstSlice), | |
80 | lastSlice(firstSlice), | |
81 | totalWritten(0), | |
82 | store(aStore), | |
83 | fileNo(aFileNo), | |
84 | buf(nullptr), | |
85 | bufSize(0), | |
86 | bufWritten(0) | |
87 | { | |
88 | Must(entry); | |
89 | } | |
90 | ||
91 | void | |
92 | ShmWriter::append(const char *aBuf, int aBufSize) | |
93 | { | |
94 | Must(!buf); | |
95 | buf = aBuf; | |
96 | bufSize = aBufSize; | |
97 | if (bufSize) { | |
98 | Must(buf); | |
99 | bufWritten = 0; | |
100 | copyToShm(); | |
101 | } | |
102 | buf = nullptr; | |
103 | bufSize = 0; | |
104 | bufWritten = 0; | |
105 | } | |
106 | ||
107 | void | |
108 | ShmWriter::vappendf(const char *fmt, va_list ap) | |
109 | { | |
110 | SBuf vaBuf; | |
111 | #if defined(VA_COPY) | |
112 | va_list apCopy; | |
113 | VA_COPY(apCopy, ap); | |
114 | vaBuf.vappendf(fmt, apCopy); | |
115 | va_end(apCopy); | |
116 | #else | |
117 | vaBuf.vappendf(fmt, ap); | |
118 | #endif | |
119 | append(vaBuf.rawContent(), vaBuf.length()); | |
120 | } | |
121 | ||
122 | /// copies the entire buffer to shared memory | |
123 | void | |
124 | ShmWriter::copyToShm() | |
125 | { | |
126 | Must(bufSize > 0); // do not use up shared memory pages for nothing | |
127 | Must(firstSlice < 0 || lastSlice >= 0); | |
128 | ||
129 | // fill, skip slices that are already full | |
130 | while (bufWritten < bufSize) { | |
131 | Ipc::StoreMap::Slice &slice = store.nextAppendableSlice(fileNo, lastSlice); | |
132 | if (firstSlice < 0) | |
133 | firstSlice = lastSlice; | |
134 | copyToShmSlice(slice); | |
135 | } | |
136 | ||
137 | debugs(20, 7, "stored " << bufWritten << '/' << totalWritten << " header bytes of " << *entry); | |
138 | } | |
139 | ||
140 | /// copies at most one slice worth of buffer to shared memory | |
141 | void | |
142 | ShmWriter::copyToShmSlice(Ipc::StoreMap::Slice &slice) | |
143 | { | |
144 | Ipc::Mem::PageId page = store.pageForSlice(lastSlice); | |
145 | debugs(20, 7, "entry " << *entry << " slice " << lastSlice << " has " << | |
146 | page); | |
147 | ||
148 | Must(bufWritten <= bufSize); | |
149 | const int64_t writingDebt = bufSize - bufWritten; | |
150 | const int64_t pageSize = Ipc::Mem::PageSize(); | |
151 | const int64_t sliceOffset = totalWritten % pageSize; | |
152 | const int64_t copySize = std::min(writingDebt, pageSize - sliceOffset); | |
153 | memcpy(static_cast<char*>(PagePointer(page)) + sliceOffset, buf + bufWritten, | |
154 | copySize); | |
155 | ||
156 | debugs(20, 7, "copied " << slice.size << '+' << copySize << " bytes of " << | |
157 | entry << " from " << sliceOffset << " in " << page); | |
158 | ||
159 | slice.size += copySize; | |
160 | bufWritten += copySize; | |
161 | totalWritten += copySize; | |
162 | // fresh anchor.basics.swap_file_sz is already set [to the stale value] | |
163 | ||
164 | // either we wrote everything or we filled the entire slice | |
165 | Must(bufWritten == bufSize || sliceOffset + copySize == pageSize); | |
166 | } | |
167 | ||
168 | /* MemStore */ | |
169 | ||
06684a9b | 170 | MemStore::MemStore(): map(NULL), lastWritingSlice(-1) |
9487bae9 AR |
171 | { |
172 | } | |
173 | ||
174 | MemStore::~MemStore() | |
175 | { | |
176 | delete map; | |
177 | } | |
178 | ||
179 | void | |
9199139f AR |
180 | MemStore::init() |
181 | { | |
a4555399 AR |
182 | const int64_t entryLimit = EntryLimit(); |
183 | if (entryLimit <= 0) | |
184 | return; // no memory cache configured or a misconfiguration | |
185 | ||
06684a9b AR |
186 | // check compatibility with the disk cache, if any |
187 | if (Config.cacheSwap.n_configured > 0) { | |
9d4e9cfb AR |
188 | const int64_t diskMaxSize = Store::Root().maxObjectSize(); |
189 | const int64_t memMaxSize = maxObjectSize(); | |
190 | if (diskMaxSize == -1) { | |
191 | debugs(20, DBG_IMPORTANT, "WARNING: disk-cache maximum object size " | |
192 | "is unlimited but mem-cache maximum object size is " << | |
193 | memMaxSize / 1024.0 << " KB"); | |
194 | } else if (diskMaxSize > memMaxSize) { | |
195 | debugs(20, DBG_IMPORTANT, "WARNING: disk-cache maximum object size " | |
196 | "is too large for mem-cache: " << | |
197 | diskMaxSize / 1024.0 << " KB > " << | |
198 | memMaxSize / 1024.0 << " KB"); | |
199 | } | |
06684a9b | 200 | } |
af2fda07 | 201 | |
06684a9b | 202 | freeSlots = shm_old(Ipc::Mem::PageStack)(SpaceLabel); |
1860fbac | 203 | extras = shm_old(Extras)(ExtrasLabel); |
06684a9b AR |
204 | |
205 | Must(!map); | |
206 | map = new MemStoreMap(MapLabel); | |
a4555399 | 207 | map->cleaner = this; |
9487bae9 AR |
208 | } |
209 | ||
93bc1434 AR |
210 | void |
211 | MemStore::getStats(StoreInfoStats &stats) const | |
212 | { | |
213 | const size_t pageSize = Ipc::Mem::PageSize(); | |
214 | ||
215 | stats.mem.shared = true; | |
216 | stats.mem.capacity = | |
217 | Ipc::Mem::PageLimit(Ipc::Mem::PageId::cachePage) * pageSize; | |
218 | stats.mem.size = | |
219 | Ipc::Mem::PageLevel(Ipc::Mem::PageId::cachePage) * pageSize; | |
220 | stats.mem.count = currentCount(); | |
221 | } | |
222 | ||
9487bae9 | 223 | void |
c4e688b7 | 224 | MemStore::stat(StoreEntry &e) const |
9487bae9 | 225 | { |
c4e688b7 AR |
226 | storeAppendPrintf(&e, "\n\nShared Memory Cache\n"); |
227 | ||
06684a9b AR |
228 | storeAppendPrintf(&e, "Maximum Size: %.0f KB\n", maxSize()/1024.0); |
229 | storeAppendPrintf(&e, "Current Size: %.2f KB %.2f%%\n", | |
230 | currentSize() / 1024.0, | |
231 | Math::doublePercent(currentSize(), maxSize())); | |
c4e688b7 AR |
232 | |
233 | if (map) { | |
36c84e19 AR |
234 | const int entryLimit = map->entryLimit(); |
235 | const int slotLimit = map->sliceLimit(); | |
236 | storeAppendPrintf(&e, "Maximum entries: %9d\n", entryLimit); | |
237 | if (entryLimit > 0) { | |
c91ca3ce | 238 | storeAppendPrintf(&e, "Current entries: %" PRId64 " %.2f%%\n", |
36c84e19 AR |
239 | currentCount(), (100.0 * currentCount() / entryLimit)); |
240 | } | |
c4e688b7 | 241 | |
36c84e19 AR |
242 | storeAppendPrintf(&e, "Maximum slots: %9d\n", slotLimit); |
243 | if (slotLimit > 0) { | |
06684a9b AR |
244 | const unsigned int slotsFree = |
245 | Ipc::Mem::PagesAvailable(Ipc::Mem::PageId::cachePage); | |
36c84e19 AR |
246 | if (slotsFree <= static_cast<const unsigned int>(slotLimit)) { |
247 | const int usedSlots = slotLimit - static_cast<const int>(slotsFree); | |
06684a9b | 248 | storeAppendPrintf(&e, "Used slots: %9d %.2f%%\n", |
36c84e19 | 249 | usedSlots, (100.0 * usedSlots / slotLimit)); |
06684a9b AR |
250 | } |
251 | ||
36c84e19 | 252 | if (slotLimit < 100) { // XXX: otherwise too expensive to count |
c4e688b7 AR |
253 | Ipc::ReadWriteLockStats stats; |
254 | map->updateStats(stats); | |
255 | stats.dump(e); | |
9199139f AR |
256 | } |
257 | } | |
258 | } | |
9487bae9 AR |
259 | } |
260 | ||
261 | void | |
262 | MemStore::maintain() | |
263 | { | |
264 | } | |
265 | ||
266 | uint64_t | |
267 | MemStore::minSize() const | |
268 | { | |
269 | return 0; // XXX: irrelevant, but Store parent forces us to implement this | |
270 | } | |
271 | ||
272 | uint64_t | |
273 | MemStore::maxSize() const | |
274 | { | |
06684a9b | 275 | return Config.memMaxSize; |
9487bae9 AR |
276 | } |
277 | ||
39c1e1d9 DK |
278 | uint64_t |
279 | MemStore::currentSize() const | |
280 | { | |
06684a9b | 281 | return Ipc::Mem::PageLevel(Ipc::Mem::PageId::cachePage) * |
9d4e9cfb | 282 | Ipc::Mem::PageSize(); |
39c1e1d9 DK |
283 | } |
284 | ||
285 | uint64_t | |
286 | MemStore::currentCount() const | |
287 | { | |
288 | return map ? map->entryCount() : 0; | |
289 | } | |
290 | ||
af2fda07 DK |
291 | int64_t |
292 | MemStore::maxObjectSize() const | |
293 | { | |
06684a9b | 294 | return min(Config.Store.maxInMemObjSize, Config.memMaxSize); |
af2fda07 DK |
295 | } |
296 | ||
9487bae9 AR |
297 | void |
298 | MemStore::reference(StoreEntry &) | |
299 | { | |
300 | } | |
301 | ||
4c973beb | 302 | bool |
2745fea5 | 303 | MemStore::dereference(StoreEntry &) |
9487bae9 | 304 | { |
4c973beb AR |
305 | // no need to keep e in the global store_table for us; we have our own map |
306 | return false; | |
9487bae9 AR |
307 | } |
308 | ||
9487bae9 AR |
309 | StoreEntry * |
310 | MemStore::get(const cache_key *key) | |
311 | { | |
312 | if (!map) | |
313 | return NULL; | |
314 | ||
9487bae9 | 315 | sfileno index; |
10dc0fe6 | 316 | const Ipc::StoreMapAnchor *const slot = map->openForReading(key, index); |
9487bae9 AR |
317 | if (!slot) |
318 | return NULL; | |
319 | ||
9487bae9 AR |
320 | // create a brand new store entry and initialize it with stored info |
321 | StoreEntry *e = new StoreEntry(); | |
9487bae9 | 322 | |
ce49546e AR |
323 | // XXX: We do not know the URLs yet, only the key, but we need to parse and |
324 | // store the response for the Root().get() callers to be happy because they | |
325 | // expect IN_MEMORY entries to already have the response headers and body. | |
c877c0bc | 326 | e->makeMemObject(); |
9487bae9 | 327 | |
ce49546e | 328 | anchorEntry(*e, index, *slot); |
9487bae9 | 329 | |
06684a9b | 330 | const bool copied = copyFromShm(*e, index, *slot); |
9487bae9 | 331 | |
9487bae9 AR |
332 | if (copied) { |
333 | e->hashInsert(key); | |
334 | return e; | |
335 | } | |
336 | ||
337 | debugs(20, 3, HERE << "mem-loading failed; freeing " << index); | |
10dc0fe6 | 338 | map->freeEntry(index); // do not let others into the same trap |
9487bae9 AR |
339 | return NULL; |
340 | } | |
341 | ||
abf396ec AR |
342 | void |
343 | MemStore::updateHeaders(StoreEntry *updatedE) | |
344 | { | |
345 | if (!map) | |
346 | return; | |
347 | ||
348 | Ipc::StoreMapUpdate update(updatedE); | |
349 | assert(updatedE); | |
350 | assert(updatedE->mem_obj); | |
351 | if (!map->openForUpdating(update, updatedE->mem_obj->memCache.index)) | |
352 | return; | |
353 | ||
354 | try { | |
355 | updateHeadersOrThrow(update); | |
356 | } catch (const std::exception &ex) { | |
357 | debugs(20, 2, "error starting to update entry " << *updatedE << ": " << ex.what()); | |
358 | map->abortUpdating(update); | |
359 | } | |
360 | } | |
361 | ||
362 | void | |
363 | MemStore::updateHeadersOrThrow(Ipc::StoreMapUpdate &update) | |
364 | { | |
365 | // our +/- hdr_sz math below does not work if the chains differ [in size] | |
366 | Must(update.stale.anchor->basics.swap_file_sz == update.fresh.anchor->basics.swap_file_sz); | |
367 | ||
368 | const HttpReply *rawReply = update.entry->getReply(); | |
369 | Must(rawReply); | |
370 | const HttpReply &reply = *rawReply; | |
371 | const uint64_t staleHdrSz = reply.hdr_sz; | |
372 | debugs(20, 7, "stale hdr_sz: " << staleHdrSz); | |
373 | ||
374 | /* we will need to copy same-slice payload after the stored headers later */ | |
375 | Must(staleHdrSz > 0); | |
376 | update.stale.splicingPoint = map->sliceContaining(update.stale.fileNo, staleHdrSz); | |
377 | Must(update.stale.splicingPoint >= 0); | |
378 | Must(update.stale.anchor->basics.swap_file_sz >= staleHdrSz); | |
379 | ||
380 | Must(update.stale.anchor); | |
381 | ShmWriter writer(*this, update.entry, update.fresh.fileNo); | |
382 | reply.packHeadersInto(&writer); | |
383 | const uint64_t freshHdrSz = writer.totalWritten; | |
384 | debugs(20, 7, "fresh hdr_sz: " << freshHdrSz << " diff: " << (freshHdrSz - staleHdrSz)); | |
385 | ||
386 | /* copy same-slice payload remaining after the stored headers */ | |
387 | const Ipc::StoreMapSlice &slice = map->readableSlice(update.stale.fileNo, update.stale.splicingPoint); | |
388 | const Ipc::StoreMapSlice::Size sliceCapacity = Ipc::Mem::PageSize(); | |
389 | const Ipc::StoreMapSlice::Size headersInLastSlice = staleHdrSz % sliceCapacity; | |
390 | Must(headersInLastSlice > 0); // or sliceContaining() would have stopped earlier | |
391 | Must(slice.size >= headersInLastSlice); | |
392 | const Ipc::StoreMapSlice::Size payloadInLastSlice = slice.size - headersInLastSlice; | |
393 | const MemStoreMapExtras::Item &extra = extras->items[update.stale.splicingPoint]; | |
394 | char *page = static_cast<char*>(PagePointer(extra.page)); | |
395 | debugs(20, 5, "appending same-slice payload: " << payloadInLastSlice); | |
396 | writer.append(page + headersInLastSlice, payloadInLastSlice); | |
397 | update.fresh.splicingPoint = writer.lastSlice; | |
398 | ||
399 | update.fresh.anchor->basics.swap_file_sz -= staleHdrSz; | |
400 | update.fresh.anchor->basics.swap_file_sz += freshHdrSz; | |
401 | ||
402 | map->closeForUpdating(update); | |
403 | } | |
404 | ||
ce49546e | 405 | bool |
4475555f | 406 | MemStore::anchorCollapsed(StoreEntry &collapsed, bool &inSync) |
ce49546e AR |
407 | { |
408 | if (!map) | |
409 | return false; | |
410 | ||
411 | sfileno index; | |
412 | const Ipc::StoreMapAnchor *const slot = map->openForReading( | |
f53969cc | 413 | reinterpret_cast<cache_key*>(collapsed.key), index); |
ce49546e AR |
414 | if (!slot) |
415 | return false; | |
416 | ||
417 | anchorEntry(collapsed, index, *slot); | |
4475555f AR |
418 | inSync = updateCollapsedWith(collapsed, index, *slot); |
419 | return true; // even if inSync is false | |
ce49546e AR |
420 | } |
421 | ||
422 | bool | |
423 | MemStore::updateCollapsed(StoreEntry &collapsed) | |
424 | { | |
c877c0bc | 425 | assert(collapsed.mem_obj); |
ce49546e | 426 | |
9d4e9cfb | 427 | const sfileno index = collapsed.mem_obj->memCache.index; |
ce49546e AR |
428 | |
429 | // already disconnected from the cache, no need to update | |
9d4e9cfb | 430 | if (index < 0) |
ce49546e AR |
431 | return true; |
432 | ||
4475555f AR |
433 | if (!map) |
434 | return false; | |
435 | ||
ce49546e AR |
436 | const Ipc::StoreMapAnchor &anchor = map->readableEntry(index); |
437 | return updateCollapsedWith(collapsed, index, anchor); | |
438 | } | |
439 | ||
e6d2c263 | 440 | /// updates collapsed entry after its anchor has been located |
ce49546e AR |
441 | bool |
442 | MemStore::updateCollapsedWith(StoreEntry &collapsed, const sfileno index, const Ipc::StoreMapAnchor &anchor) | |
443 | { | |
e6d2c263 | 444 | collapsed.swap_file_sz = anchor.basics.swap_file_sz; |
ce49546e | 445 | const bool copied = copyFromShm(collapsed, index, anchor); |
e6d2c263 | 446 | return copied; |
ce49546e AR |
447 | } |
448 | ||
449 | /// anchors StoreEntry to an already locked map entry | |
450 | void | |
451 | MemStore::anchorEntry(StoreEntry &e, const sfileno index, const Ipc::StoreMapAnchor &anchor) | |
452 | { | |
453 | const Ipc::StoreMapAnchor::Basics &basics = anchor.basics; | |
454 | ||
455 | e.swap_file_sz = basics.swap_file_sz; | |
456 | e.lastref = basics.lastref; | |
457 | e.timestamp = basics.timestamp; | |
458 | e.expires = basics.expires; | |
459 | e.lastmod = basics.lastmod; | |
460 | e.refcount = basics.refcount; | |
461 | e.flags = basics.flags; | |
462 | ||
463 | assert(e.mem_obj); | |
4475555f AR |
464 | if (anchor.complete()) { |
465 | e.store_status = STORE_OK; | |
466 | e.mem_obj->object_sz = e.swap_file_sz; | |
1bfe9ade | 467 | e.setMemStatus(IN_MEMORY); |
4475555f AR |
468 | } else { |
469 | e.store_status = STORE_PENDING; | |
470 | assert(e.mem_obj->object_sz < 0); | |
1bfe9ade | 471 | e.setMemStatus(NOT_IN_MEMORY); |
4475555f | 472 | } |
ce49546e AR |
473 | assert(e.swap_status == SWAPOUT_NONE); // set in StoreEntry constructor |
474 | e.ping_status = PING_NONE; | |
475 | ||
ce49546e AR |
476 | EBIT_CLR(e.flags, RELEASE_REQUEST); |
477 | EBIT_CLR(e.flags, KEY_PRIVATE); | |
478 | EBIT_SET(e.flags, ENTRY_VALIDATED); | |
4475555f AR |
479 | |
480 | MemObject::MemCache &mc = e.mem_obj->memCache; | |
481 | mc.index = index; | |
99921d9d | 482 | mc.io = MemObject::ioReading; |
ce49546e AR |
483 | } |
484 | ||
06684a9b | 485 | /// copies the entire entry from shared to local memory |
9487bae9 | 486 | bool |
06684a9b | 487 | MemStore::copyFromShm(StoreEntry &e, const sfileno index, const Ipc::StoreMapAnchor &anchor) |
9487bae9 | 488 | { |
06684a9b | 489 | debugs(20, 7, "mem-loading entry " << index << " from " << anchor.start); |
4475555f | 490 | assert(e.mem_obj); |
9487bae9 | 491 | |
9487bae9 AR |
492 | // emulate the usual Store code but w/o inapplicable checks and callbacks: |
493 | ||
ce49546e AR |
494 | Ipc::StoreMapSliceId sid = anchor.start; // optimize: remember the last sid |
495 | bool wasEof = anchor.complete() && sid < 0; | |
496 | int64_t sliceOffset = 0; | |
06684a9b AR |
497 | while (sid >= 0) { |
498 | const Ipc::StoreMapSlice &slice = map->readableSlice(index, sid); | |
ce49546e AR |
499 | // slice state may change during copying; take snapshots now |
500 | wasEof = anchor.complete() && slice.next < 0; | |
501 | const Ipc::StoreMapSlice::Size wasSize = slice.size; | |
4475555f AR |
502 | |
503 | debugs(20, 9, "entry " << index << " slice " << sid << " eof " << | |
504 | wasEof << " wasSize " << wasSize << " <= " << | |
505 | anchor.basics.swap_file_sz << " sliceOffset " << sliceOffset << | |
506 | " mem.endOffset " << e.mem_obj->endOffset()); | |
9d4e9cfb AR |
507 | |
508 | if (e.mem_obj->endOffset() < sliceOffset + wasSize) { | |
ce49546e AR |
509 | // size of the slice data that we already copied |
510 | const size_t prefixSize = e.mem_obj->endOffset() - sliceOffset; | |
511 | assert(prefixSize <= wasSize); | |
512 | ||
1860fbac AR |
513 | const MemStoreMapExtras::Item &extra = extras->items[sid]; |
514 | ||
515 | char *page = static_cast<char*>(PagePointer(extra.page)); | |
ce49546e AR |
516 | const StoreIOBuffer sliceBuf(wasSize - prefixSize, |
517 | e.mem_obj->endOffset(), | |
518 | page + prefixSize); | |
519 | if (!copyFromShmSlice(e, sliceBuf, wasEof)) | |
520 | return false; | |
521 | debugs(20, 9, "entry " << index << " copied slice " << sid << | |
1860fbac | 522 | " from " << extra.page << '+' << prefixSize); |
ce49546e AR |
523 | } |
524 | // else skip a [possibly incomplete] slice that we copied earlier | |
525 | ||
526 | // careful: the slice may have grown _and_ gotten the next slice ID! | |
527 | if (slice.next >= 0) { | |
528 | assert(!wasEof); | |
529 | // here we know that slice.size may not change any more | |
530 | if (wasSize >= slice.size) { // did not grow since we started copying | |
531 | sliceOffset += wasSize; | |
532 | sid = slice.next; | |
9d4e9cfb | 533 | } |
ce49546e AR |
534 | } else if (wasSize >= slice.size) { // did not grow |
535 | break; | |
536 | } | |
537 | } | |
538 | ||
539 | if (!wasEof) { | |
540 | debugs(20, 7, "mem-loaded " << e.mem_obj->endOffset() << '/' << | |
541 | anchor.basics.swap_file_sz << " bytes of " << e); | |
542 | return true; | |
9487bae9 | 543 | } |
9487bae9 | 544 | |
06684a9b AR |
545 | debugs(20, 7, "mem-loaded all " << e.mem_obj->object_sz << '/' << |
546 | anchor.basics.swap_file_sz << " bytes of " << e); | |
99921d9d AR |
547 | |
548 | // from StoreEntry::complete() | |
549 | e.mem_obj->object_sz = e.mem_obj->endOffset(); | |
550 | e.store_status = STORE_OK; | |
1bfe9ade | 551 | e.setMemStatus(IN_MEMORY); |
99921d9d | 552 | |
06684a9b AR |
553 | assert(e.mem_obj->object_sz >= 0); |
554 | assert(static_cast<uint64_t>(e.mem_obj->object_sz) == anchor.basics.swap_file_sz); | |
9487bae9 AR |
555 | // would be nice to call validLength() here, but it needs e.key |
556 | ||
99921d9d | 557 | // we read the entire response into the local memory; no more need to lock |
29c56e41 | 558 | disconnect(e); |
9487bae9 AR |
559 | return true; |
560 | } | |
561 | ||
06684a9b AR |
562 | /// imports one shared memory slice into local memory |
563 | bool | |
ce49546e | 564 | MemStore::copyFromShmSlice(StoreEntry &e, const StoreIOBuffer &buf, bool eof) |
06684a9b AR |
565 | { |
566 | debugs(20, 7, "buf: " << buf.offset << " + " << buf.length); | |
567 | ||
568 | // from store_client::readBody() | |
569 | // parse headers if needed; they might span multiple slices! | |
570 | HttpReply *rep = (HttpReply *)e.getReply(); | |
571 | if (rep->pstate < psParsed) { | |
572 | // XXX: have to copy because httpMsgParseStep() requires 0-termination | |
573 | MemBuf mb; | |
574 | mb.init(buf.length+1, buf.length+1); | |
9d4e9cfb | 575 | mb.append(buf.data, buf.length); |
06684a9b AR |
576 | mb.terminate(); |
577 | const int result = rep->httpMsgParseStep(mb.buf, buf.length, eof); | |
578 | if (result > 0) { | |
579 | assert(rep->pstate == psParsed); | |
4475555f | 580 | EBIT_CLR(e.flags, ENTRY_FWD_HDR_WAIT); |
06684a9b AR |
581 | } else if (result < 0) { |
582 | debugs(20, DBG_IMPORTANT, "Corrupted mem-cached headers: " << e); | |
583 | return false; | |
584 | } else { // more slices are needed | |
585 | assert(!eof); | |
586 | } | |
587 | } | |
588 | debugs(20, 7, "rep pstate: " << rep->pstate); | |
589 | ||
590 | // local memory stores both headers and body so copy regardless of pstate | |
591 | const int64_t offBefore = e.mem_obj->endOffset(); | |
592 | assert(e.mem_obj->data_hdr.write(buf)); // from MemObject::write() | |
593 | const int64_t offAfter = e.mem_obj->endOffset(); | |
594 | // expect to write the entire buf because StoreEntry::write() never fails | |
595 | assert(offAfter >= 0 && offBefore <= offAfter && | |
596 | static_cast<size_t>(offAfter - offBefore) == buf.length); | |
597 | return true; | |
598 | } | |
599 | ||
4475555f | 600 | /// whether we should cache the entry |
96a7de88 | 601 | bool |
97754f5a | 602 | MemStore::shouldCache(StoreEntry &e) const |
9487bae9 | 603 | { |
4475555f AR |
604 | if (e.mem_status == IN_MEMORY) { |
605 | debugs(20, 5, "already loaded from mem-cache: " << e); | |
606 | return false; | |
607 | } | |
608 | ||
609 | if (e.mem_obj && e.mem_obj->memCache.offset > 0) { | |
610 | debugs(20, 5, "already written to mem-cache: " << e); | |
611 | return false; | |
612 | } | |
613 | ||
9487bae9 AR |
614 | if (!e.memoryCachable()) { |
615 | debugs(20, 7, HERE << "Not memory cachable: " << e); | |
96a7de88 DK |
616 | return false; // will not cache due to entry state or properties |
617 | } | |
618 | ||
619 | assert(e.mem_obj); | |
b8a899c0 | 620 | |
90ab8f20 | 621 | if (!e.mem_obj->vary_headers.isEmpty()) { |
b8a899c0 AR |
622 | // XXX: We must store/load SerialisedMetaData to cache Vary in RAM |
623 | debugs(20, 5, "Vary not yet supported: " << e.mem_obj->vary_headers); | |
624 | return false; | |
625 | } | |
626 | ||
96a7de88 | 627 | const int64_t expectedSize = e.mem_obj->expectedReplySize(); // may be < 0 |
4475555f AR |
628 | |
629 | // objects of unknown size are not allowed into memory cache, for now | |
630 | if (expectedSize < 0) { | |
539283df | 631 | debugs(20, 5, "Unknown expected size: " << e); |
4475555f AR |
632 | return false; |
633 | } | |
634 | ||
635 | const int64_t loadedSize = e.mem_obj->endOffset(); | |
96a7de88 DK |
636 | const int64_t ramSize = max(loadedSize, expectedSize); |
637 | ||
06684a9b | 638 | if (ramSize > maxObjectSize()) { |
96a7de88 DK |
639 | debugs(20, 5, HERE << "Too big max(" << |
640 | loadedSize << ", " << expectedSize << "): " << e); | |
641 | return false; // will not cache due to cachable entry size limits | |
642 | } | |
643 | ||
97754f5a AR |
644 | if (!e.mem_obj->isContiguous()) { |
645 | debugs(20, 5, "not contiguous"); | |
646 | return false; | |
647 | } | |
648 | ||
4475555f AR |
649 | if (!map) { |
650 | debugs(20, 5, HERE << "No map to mem-cache " << e); | |
651 | return false; | |
652 | } | |
653 | ||
99921d9d | 654 | if (EBIT_TEST(e.flags, ENTRY_SPECIAL)) { |
539283df | 655 | debugs(20, 5, "Not mem-caching ENTRY_SPECIAL " << e); |
99921d9d AR |
656 | return false; |
657 | } | |
658 | ||
96a7de88 DK |
659 | return true; |
660 | } | |
661 | ||
4475555f AR |
662 | /// locks map anchor and preps to store the entry in shared memory |
663 | bool | |
664 | MemStore::startCaching(StoreEntry &e) | |
96a7de88 | 665 | { |
4475555f AR |
666 | sfileno index = 0; |
667 | Ipc::StoreMapAnchor *slot = map->openForWriting(reinterpret_cast<const cache_key *>(e.key), index); | |
668 | if (!slot) { | |
669 | debugs(20, 5, HERE << "No room in mem-cache map to index " << e); | |
670 | return false; | |
449ca8c5 AR |
671 | } |
672 | ||
4475555f AR |
673 | assert(e.mem_obj); |
674 | e.mem_obj->memCache.index = index; | |
99921d9d | 675 | e.mem_obj->memCache.io = MemObject::ioWriting; |
4475555f AR |
676 | slot->set(e); |
677 | map->startAppending(index); | |
0cdcf3d7 | 678 | e.memOutDecision(true); |
4475555f AR |
679 | return true; |
680 | } | |
681 | ||
682 | /// copies all local data to shared memory | |
683 | void | |
684 | MemStore::copyToShm(StoreEntry &e) | |
685 | { | |
686 | // prevents remote readers from getting ENTRY_FWD_HDR_WAIT entries and | |
687 | // not knowing when the wait is over | |
688 | if (EBIT_TEST(e.flags, ENTRY_FWD_HDR_WAIT)) { | |
689 | debugs(20, 5, "postponing copying " << e << " for ENTRY_FWD_HDR_WAIT"); | |
9d4e9cfb | 690 | return; |
06684a9b AR |
691 | } |
692 | ||
4475555f | 693 | assert(map); |
9487bae9 | 694 | assert(e.mem_obj); |
449ca8c5 | 695 | |
4475555f AR |
696 | const int64_t eSize = e.mem_obj->endOffset(); |
697 | if (e.mem_obj->memCache.offset >= eSize) { | |
698 | debugs(20, 5, "postponing copying " << e << " for lack of news: " << | |
699 | e.mem_obj->memCache.offset << " >= " << eSize); | |
700 | return; // nothing to do (yet) | |
96a7de88 DK |
701 | } |
702 | ||
abf396ec AR |
703 | const int32_t index = e.mem_obj->memCache.index; |
704 | assert(index >= 0); | |
705 | Ipc::StoreMapAnchor &anchor = map->writeableEntry(index); | |
4475555f | 706 | lastWritingSlice = anchor.start; |
9487bae9 | 707 | |
4475555f AR |
708 | // fill, skip slices that are already full |
709 | // Optimize: remember lastWritingSlice in e.mem_obj | |
710 | while (e.mem_obj->memCache.offset < eSize) { | |
abf396ec AR |
711 | Ipc::StoreMap::Slice &slice = nextAppendableSlice( |
712 | e.mem_obj->memCache.index, lastWritingSlice); | |
713 | if (anchor.start < 0) | |
714 | anchor.start = lastWritingSlice; | |
715 | copyToShmSlice(e, anchor, slice); | |
9487bae9 | 716 | } |
06684a9b | 717 | |
4475555f | 718 | debugs(20, 7, "mem-cached available " << eSize << " bytes of " << e); |
9487bae9 AR |
719 | } |
720 | ||
4475555f AR |
721 | /// copies at most one slice worth of local memory to shared memory |
722 | void | |
abf396ec | 723 | MemStore::copyToShmSlice(StoreEntry &e, Ipc::StoreMapAnchor &anchor, Ipc::StoreMap::Slice &slice) |
06684a9b | 724 | { |
abf396ec | 725 | Ipc::Mem::PageId page = pageForSlice(lastWritingSlice); |
4475555f AR |
726 | debugs(20, 7, "entry " << e << " slice " << lastWritingSlice << " has " << |
727 | page); | |
9487bae9 AR |
728 | |
729 | const int64_t bufSize = Ipc::Mem::PageSize(); | |
4475555f AR |
730 | const int64_t sliceOffset = e.mem_obj->memCache.offset % bufSize; |
731 | StoreIOBuffer sharedSpace(bufSize - sliceOffset, e.mem_obj->memCache.offset, | |
732 | static_cast<char*>(PagePointer(page)) + sliceOffset); | |
9199139f | 733 | |
9487bae9 AR |
734 | // check that we kept everything or purge incomplete/sparse cached entry |
735 | const ssize_t copied = e.mem_obj->data_hdr.copy(sharedSpace); | |
06684a9b | 736 | if (copied <= 0) { |
4475555f AR |
737 | debugs(20, 2, "Failed to mem-cache " << (bufSize - sliceOffset) << |
738 | " bytes of " << e << " from " << e.mem_obj->memCache.offset << | |
739 | " in " << page); | |
740 | throw TexcHere("data_hdr.copy failure"); | |
9487bae9 AR |
741 | } |
742 | ||
06684a9b | 743 | debugs(20, 7, "mem-cached " << copied << " bytes of " << e << |
4475555f | 744 | " from " << e.mem_obj->memCache.offset << " in " << page); |
06684a9b | 745 | |
4475555f AR |
746 | slice.size += copied; |
747 | e.mem_obj->memCache.offset += copied; | |
76ba3c8a | 748 | anchor.basics.swap_file_sz = e.mem_obj->memCache.offset; |
9487bae9 | 749 | } |
7f6748c8 | 750 | |
abf396ec AR |
751 | /// starts checking with the entry chain slice at a given offset and |
752 | /// returns a not-full (but not necessarily empty) slice, updating sliceOffset | |
753 | Ipc::StoreMap::Slice & | |
754 | MemStore::nextAppendableSlice(const sfileno fileNo, sfileno &sliceOffset) | |
755 | { | |
756 | // allocate the very first slot for the entry if needed | |
757 | if (sliceOffset < 0) { | |
758 | Ipc::StoreMapAnchor &anchor = map->writeableEntry(fileNo); | |
759 | Must(anchor.start < 0); | |
760 | Ipc::Mem::PageId page; | |
761 | sliceOffset = reserveSapForWriting(page); // throws | |
762 | extras->items[sliceOffset].page = page; | |
763 | anchor.start = sliceOffset; | |
764 | } | |
765 | ||
766 | const size_t sliceCapacity = Ipc::Mem::PageSize(); | |
767 | do { | |
768 | Ipc::StoreMap::Slice &slice = map->writeableSlice(fileNo, sliceOffset); | |
769 | ||
770 | if (slice.size >= sliceCapacity) { | |
771 | if (slice.next >= 0) { | |
772 | sliceOffset = slice.next; | |
773 | continue; | |
774 | } | |
775 | ||
776 | Ipc::Mem::PageId page; | |
777 | slice.next = sliceOffset = reserveSapForWriting(page); | |
778 | extras->items[sliceOffset].page = page; | |
779 | debugs(20, 7, "entry " << fileNo << " new slice: " << sliceOffset); | |
780 | } | |
781 | ||
782 | return slice; | |
783 | } while (true); | |
784 | /* not reached */ | |
785 | } | |
786 | ||
787 | /// safely returns a previously allocated memory page for the given entry slice | |
788 | Ipc::Mem::PageId | |
789 | MemStore::pageForSlice(Ipc::StoreMapSliceId sliceId) | |
790 | { | |
791 | Must(extras); | |
792 | Must(sliceId >= 0); | |
793 | Ipc::Mem::PageId page = extras->items[sliceId].page; | |
794 | Must(page); | |
795 | return page; | |
796 | } | |
797 | ||
06684a9b AR |
798 | /// finds a slot and a free page to fill or throws |
799 | sfileno | |
800 | MemStore::reserveSapForWriting(Ipc::Mem::PageId &page) | |
7f6748c8 | 801 | { |
06684a9b AR |
802 | Ipc::Mem::PageId slot; |
803 | if (freeSlots->pop(slot)) { | |
804 | debugs(20, 5, "got a previously free slot: " << slot); | |
805 | ||
806 | if (Ipc::Mem::GetPage(Ipc::Mem::PageId::cachePage, page)) { | |
807 | debugs(20, 5, "and got a previously free page: " << page); | |
808 | return slot.number - 1; | |
809 | } else { | |
810 | debugs(20, 3, "but there is no free page, returning " << slot); | |
811 | freeSlots->push(slot); | |
812 | } | |
813 | } | |
9d4e9cfb | 814 | |
06684a9b AR |
815 | // catch free slots delivered to noteFreeMapSlice() |
816 | assert(!waitingFor); | |
817 | waitingFor.slot = &slot; | |
818 | waitingFor.page = &page; | |
819 | if (map->purgeOne()) { | |
820 | assert(!waitingFor); // noteFreeMapSlice() should have cleared it | |
821 | assert(slot.set()); | |
822 | assert(page.set()); | |
823 | debugs(20, 5, "got previously busy " << slot << " and " << page); | |
824 | return slot.number - 1; | |
825 | } | |
826 | assert(waitingFor.slot == &slot && waitingFor.page == &page); | |
827 | waitingFor.slot = NULL; | |
828 | waitingFor.page = NULL; | |
829 | ||
830 | debugs(47, 3, "cannot get a slice; entries: " << map->entryCount()); | |
831 | throw TexcHere("ran out of mem-cache slots"); | |
832 | } | |
833 | ||
834 | void | |
36c84e19 | 835 | MemStore::noteFreeMapSlice(const Ipc::StoreMapSliceId sliceId) |
06684a9b | 836 | { |
1860fbac | 837 | Ipc::Mem::PageId &pageId = extras->items[sliceId].page; |
06684a9b AR |
838 | debugs(20, 9, "slice " << sliceId << " freed " << pageId); |
839 | assert(pageId); | |
840 | Ipc::Mem::PageId slotId; | |
841 | slotId.pool = SpacePoolId; | |
842 | slotId.number = sliceId + 1; | |
843 | if (!waitingFor) { | |
844 | // must zero pageId before we give slice (and pageId extras!) to others | |
845 | Ipc::Mem::PutPage(pageId); | |
846 | freeSlots->push(slotId); | |
847 | } else { | |
848 | *waitingFor.slot = slotId; | |
849 | *waitingFor.page = pageId; | |
850 | waitingFor.slot = NULL; | |
851 | waitingFor.page = NULL; | |
852 | pageId = Ipc::Mem::PageId(); | |
853 | } | |
7f6748c8 AR |
854 | } |
855 | ||
ce49546e | 856 | void |
4475555f | 857 | MemStore::write(StoreEntry &e) |
ce49546e AR |
858 | { |
859 | assert(e.mem_obj); | |
4475555f AR |
860 | |
861 | debugs(20, 7, "entry " << e); | |
862 | ||
863 | switch (e.mem_obj->memCache.io) { | |
99921d9d | 864 | case MemObject::ioUndecided: |
4475555f | 865 | if (!shouldCache(e) || !startCaching(e)) { |
99921d9d | 866 | e.mem_obj->memCache.io = MemObject::ioDone; |
0cdcf3d7 | 867 | e.memOutDecision(false); |
4475555f AR |
868 | return; |
869 | } | |
870 | break; | |
9d4e9cfb | 871 | |
99921d9d AR |
872 | case MemObject::ioDone: |
873 | case MemObject::ioReading: | |
4475555f AR |
874 | return; // we should not write in all of the above cases |
875 | ||
99921d9d | 876 | case MemObject::ioWriting: |
4475555f AR |
877 | break; // already decided to write and still writing |
878 | } | |
879 | ||
880 | try { | |
881 | copyToShm(e); | |
882 | if (e.store_status == STORE_OK) // done receiving new content | |
883 | completeWriting(e); | |
99921d9d AR |
884 | else |
885 | CollapsedForwarding::Broadcast(e); | |
4475555f | 886 | return; |
9d4e9cfb | 887 | } catch (const std::exception &x) { // TODO: should we catch ... as well? |
4475555f AR |
888 | debugs(20, 2, "mem-caching error writing entry " << e << ": " << x.what()); |
889 | // fall through to the error handling code | |
890 | } | |
891 | ||
29c56e41 | 892 | disconnect(e); |
4475555f AR |
893 | } |
894 | ||
895 | void | |
896 | MemStore::completeWriting(StoreEntry &e) | |
897 | { | |
898 | assert(e.mem_obj); | |
899 | const int32_t index = e.mem_obj->memCache.index; | |
900 | assert(index >= 0); | |
901 | assert(map); | |
902 | ||
903 | debugs(20, 5, "mem-cached all " << e.mem_obj->memCache.offset << " bytes of " << e); | |
904 | ||
905 | e.mem_obj->memCache.index = -1; | |
99921d9d | 906 | e.mem_obj->memCache.io = MemObject::ioDone; |
4475555f | 907 | map->closeForWriting(index, false); |
99921d9d AR |
908 | |
909 | CollapsedForwarding::Broadcast(e); // before we close our transient entry! | |
910 | Store::Root().transientsCompleteWriting(e); | |
4475555f AR |
911 | } |
912 | ||
1bfe9ade AR |
913 | void |
914 | MemStore::markForUnlink(StoreEntry &e) | |
915 | { | |
916 | assert(e.mem_obj); | |
917 | if (e.mem_obj->memCache.index >= 0) | |
918 | map->freeEntry(e.mem_obj->memCache.index); | |
919 | } | |
920 | ||
4475555f AR |
921 | void |
922 | MemStore::unlink(StoreEntry &e) | |
923 | { | |
e41a207f | 924 | if (e.mem_obj && e.mem_obj->memCache.index >= 0) { |
c877c0bc | 925 | map->freeEntry(e.mem_obj->memCache.index); |
29c56e41 | 926 | disconnect(e); |
5b675efa | 927 | } else if (map) { |
29c56e41 | 928 | // the entry may have been loaded and then disconnected from the cache |
ce49546e AR |
929 | map->freeEntryByKey(reinterpret_cast<cache_key*>(e.key)); |
930 | } | |
9d4e9cfb | 931 | |
4475555f | 932 | e.destroyMemObject(); // XXX: but it may contain useful info such as a client list. The old code used to do that though, right? |
ce49546e AR |
933 | } |
934 | ||
935 | void | |
29c56e41 | 936 | MemStore::disconnect(StoreEntry &e) |
ce49546e | 937 | { |
29c56e41 AR |
938 | assert(e.mem_obj); |
939 | MemObject &mem_obj = *e.mem_obj; | |
4475555f | 940 | if (mem_obj.memCache.index >= 0) { |
99921d9d | 941 | if (mem_obj.memCache.io == MemObject::ioWriting) { |
4475555f | 942 | map->abortWriting(mem_obj.memCache.index); |
29c56e41 AR |
943 | mem_obj.memCache.index = -1; |
944 | mem_obj.memCache.io = MemObject::ioDone; | |
945 | Store::Root().transientsAbandon(e); // broadcasts after the change | |
4475555f | 946 | } else { |
99921d9d | 947 | assert(mem_obj.memCache.io == MemObject::ioReading); |
4475555f | 948 | map->closeForReading(mem_obj.memCache.index); |
29c56e41 AR |
949 | mem_obj.memCache.index = -1; |
950 | mem_obj.memCache.io = MemObject::ioDone; | |
4475555f | 951 | } |
ce49546e AR |
952 | } |
953 | } | |
954 | ||
a4555399 AR |
955 | /// calculates maximum number of entries we need to store and map |
956 | int64_t | |
957 | MemStore::EntryLimit() | |
958 | { | |
45e8762c | 959 | if (!Config.memShared || !Config.memMaxSize) |
a4555399 AR |
960 | return 0; // no memory cache configured |
961 | ||
06684a9b AR |
962 | const int64_t minEntrySize = Ipc::Mem::PageSize(); |
963 | const int64_t entryLimit = Config.memMaxSize / minEntrySize; | |
a4555399 AR |
964 | return entryLimit; |
965 | } | |
966 | ||
21b7990f AR |
967 | /// reports our needs for shared memory pages to Ipc::Mem::Pages; |
968 | /// decides whether to use a shared memory cache or checks its configuration; | |
969 | /// and initializes shared memory segments used by MemStore | |
970 | class MemStoreRr: public Ipc::Mem::RegisteredRunner | |
ea2cdeb6 DK |
971 | { |
972 | public: | |
973 | /* RegisteredRunner API */ | |
1860fbac | 974 | MemStoreRr(): spaceOwner(NULL), mapOwner(NULL), extrasOwner(NULL) {} |
21b7990f AR |
975 | virtual void finalizeConfig(); |
976 | virtual void claimMemoryNeeds(); | |
977 | virtual void useConfig(); | |
978 | virtual ~MemStoreRr(); | |
979 | ||
980 | protected: | |
981 | /* Ipc::Mem::RegisteredRunner API */ | |
982 | virtual void create(); | |
983 | ||
984 | private: | |
985 | Ipc::Mem::Owner<Ipc::Mem::PageStack> *spaceOwner; ///< free slices Owner | |
986 | MemStoreMap::Owner *mapOwner; ///< primary map Owner | |
1860fbac | 987 | Ipc::Mem::Owner<MemStoreMapExtras> *extrasOwner; ///< PageIds Owner |
ea2cdeb6 DK |
988 | }; |
989 | ||
21b7990f | 990 | RunnerRegistrationEntry(MemStoreRr); |
ea2cdeb6 | 991 | |
ea2cdeb6 | 992 | void |
21b7990f | 993 | MemStoreRr::claimMemoryNeeds() |
ea2cdeb6 DK |
994 | { |
995 | Ipc::Mem::NotePageNeed(Ipc::Mem::PageId::cachePage, MemStore::EntryLimit()); | |
996 | } | |
997 | ||
21b7990f AR |
998 | void |
999 | MemStoreRr::finalizeConfig() | |
a4555399 | 1000 | { |
57af1e3f AR |
1001 | // decide whether to use a shared memory cache if the user did not specify |
1002 | if (!Config.memShared.configured()) { | |
75777642 | 1003 | Config.memShared.configure(Ipc::Mem::Segment::Enabled() && UsingSmp() && |
9199139f | 1004 | Config.memMaxSize > 0); |
9199139f | 1005 | } else if (Config.memShared && !Ipc::Mem::Segment::Enabled()) { |
c975f532 | 1006 | fatal("memory_cache_shared is on, but no support for shared memory detected"); |
53bbccec DK |
1007 | } else if (Config.memShared && !UsingSmp()) { |
1008 | debugs(20, DBG_IMPORTANT, "WARNING: memory_cache_shared is on, but only" | |
1009 | " a single worker is running"); | |
57af1e3f | 1010 | } |
45e8762c AR |
1011 | } |
1012 | ||
21b7990f AR |
1013 | void |
1014 | MemStoreRr::useConfig() | |
45e8762c AR |
1015 | { |
1016 | assert(Config.memShared.configured()); | |
21b7990f | 1017 | Ipc::Mem::RegisteredRunner::useConfig(); |
4404f1c5 DK |
1018 | } |
1019 | ||
21b7990f AR |
1020 | void |
1021 | MemStoreRr::create() | |
4404f1c5 | 1022 | { |
57af1e3f | 1023 | if (!Config.memShared) |
60be8b2d | 1024 | return; |
a4555399 | 1025 | |
4404f1c5 | 1026 | const int64_t entryLimit = MemStore::EntryLimit(); |
ea2cdeb6 DK |
1027 | if (entryLimit <= 0) { |
1028 | if (Config.memMaxSize > 0) { | |
1029 | debugs(20, DBG_IMPORTANT, "WARNING: mem-cache size is too small (" | |
1030 | << (Config.memMaxSize / 1024.0) << " KB), should be >= " << | |
1031 | (Ipc::Mem::PageSize() / 1024.0) << " KB"); | |
1032 | } | |
4404f1c5 | 1033 | return; // no memory cache configured or a misconfiguration |
ea2cdeb6 | 1034 | } |
06684a9b AR |
1035 | |
1036 | Must(!spaceOwner); | |
1037 | spaceOwner = shm_new(Ipc::Mem::PageStack)(SpaceLabel, SpacePoolId, | |
636b913c | 1038 | entryLimit, 0); |
06684a9b AR |
1039 | Must(!mapOwner); |
1040 | mapOwner = MemStoreMap::Init(MapLabel, entryLimit); | |
1860fbac AR |
1041 | Must(!extrasOwner); |
1042 | extrasOwner = shm_new(MemStoreMapExtras)(ExtrasLabel, entryLimit); | |
a4555399 | 1043 | } |
c011f9bc DK |
1044 | |
1045 | MemStoreRr::~MemStoreRr() | |
1046 | { | |
1860fbac | 1047 | delete extrasOwner; |
06684a9b AR |
1048 | delete mapOwner; |
1049 | delete spaceOwner; | |
c011f9bc | 1050 | } |
f53969cc | 1051 |