src/Transients.cc

   1 /*
   2  * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
   3  *
   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.
   7  */
   8
   9 /* DEBUG: section 20    Storage Manager */
  10
  11 #include "squid.h"
  12 #include "base/RunnersRegistry.h"
  13 #include "CollapsedForwarding.h"
  14 #include "HttpReply.h"
  15 #include "ipc/mem/Page.h"
  16 #include "ipc/mem/Pages.h"
  17 #include "MemObject.h"
  18 #include "mime_header.h"
  19 #include "SquidConfig.h"
  20 #include "SquidMath.h"
  21 #include "StoreStats.h"
  22 #include "tools.h"
  23 #include "Transients.h"
  24
  25 #include <limits>
  26
  27 /// shared memory segment path to use for Transients map
  28 static const SBuf MapLabel("transients_map");
  29
  30 Transients::Transients(): map(nullptr), locals(nullptr)
  31 {
  32 }
  33
  34 Transients::~Transients()
  35 {
  36     delete map;
  37     delete locals;
  38 }
  39
  40 void
  41 Transients::init()
  42 {
  43     assert(Enabled());
  44     const int64_t entryLimit = EntryLimit();
  45     assert(entryLimit > 0);
  46
  47     Must(!map);
  48     map = new TransientsMap(MapLabel);
  49     map->cleaner = this;
  50     map->disableHitValidation(); // Transients lacks slices to validate
  51
  52     locals = new Locals(entryLimit, nullptr);
  53 }
  54
  55 void
  56 Transients::getStats(StoreInfoStats &stats) const
  57 {
  58 #if TRANSIENT_STATS_SUPPORTED
  59     const size_t pageSize = Ipc::Mem::PageSize();
  60
  61     stats.mem.shared = true;
  62     stats.mem.capacity =
  63         Ipc::Mem::PageLimit(Ipc::Mem::PageId::cachePage) * pageSize;
  64     stats.mem.size =
  65         Ipc::Mem::PageLevel(Ipc::Mem::PageId::cachePage) * pageSize;
  66     stats.mem.count = currentCount();
  67 #else
  68     (void)stats;
  69 #endif
  70 }
  71
  72 void
  73 Transients::stat(StoreEntry &e) const
  74 {
  75     storeAppendPrintf(&e, "\n\nTransient Objects\n");
  76
  77     storeAppendPrintf(&e, "Maximum Size: %.0f KB\n", maxSize()/1024.0);
  78     storeAppendPrintf(&e, "Current Size: %.2f KB %.2f%%\n",
  79                       currentSize() / 1024.0,
  80                       Math::doublePercent(currentSize(), maxSize()));
  81
  82     if (map) {
  83         const int limit = map->entryLimit();
  84         storeAppendPrintf(&e, "Maximum entries: %9d\n", limit);
  85         if (limit > 0) {
  86             storeAppendPrintf(&e, "Current entries: %" PRId64 " %.2f%%\n",
  87                               currentCount(), (100.0 * currentCount() / limit));
  88         }
  89     }
  90 }
  91
  92 void
  93 Transients::maintain()
  94 {
  95     // no lazy garbage collection needed
  96 }
  97
  98 uint64_t
  99 Transients::minSize() const
 100 {
 101     return 0; // XXX: irrelevant, but Store parent forces us to implement this
 102 }
 103
 104 uint64_t
 105 Transients::maxSize() const
 106 {
 107     // Squid currently does not limit the total size of all transient objects
 108     return std::numeric_limits<uint64_t>::max();
 109 }
 110
 111 uint64_t
 112 Transients::currentSize() const
 113 {
 114     // TODO: we do not get enough information to calculate this
 115     // StoreEntry should update associated stores when its size changes
 116     return 0;
 117 }
 118
 119 uint64_t
 120 Transients::currentCount() const
 121 {
 122     return map ? map->entryCount() : 0;
 123 }
 124
 125 int64_t
 126 Transients::maxObjectSize() const
 127 {
 128     // Squid currently does not limit the size of a transient object
 129     return std::numeric_limits<uint64_t>::max();
 130 }
 131
 132 void
 133 Transients::reference(StoreEntry &)
 134 {
 135     // no replacement policy (but the cache(s) storing the entry may have one)
 136 }
 137
 138 bool
 139 Transients::dereference(StoreEntry &)
 140 {
 141     // no need to keep e in the global store_table for us; we have our own map
 142     return false;
 143 }
 144
 145 StoreEntry *
 146 Transients::get(const cache_key *key)
 147 {
 148     if (!map)
 149         return nullptr;
 150
 151     sfileno index;
 152     const Ipc::StoreMapAnchor *anchor = map->openForReading(key, index);
 153     if (!anchor)
 154         return nullptr;
 155
 156     // If we already have a local entry, the store_table should have found it.
 157     // Since it did not, the local entry key must have changed from public to
 158     // private. We still need to keep the private entry around for syncing as
 159     // its clients depend on it, but we should not allow new clients to join.
 160     if (StoreEntry *oldE = locals->at(index)) {
 161         debugs(20, 3, "not joining private " << *oldE);
 162         assert(EBIT_TEST(oldE->flags, KEY_PRIVATE));
 163         map->closeForReadingAndFreeIdle(index);
 164         return nullptr;
 165     }
 166
 167     StoreEntry *e = new StoreEntry();
 168     e->createMemObject();
 169     e->mem_obj->xitTable.open(index, Store::ioReading);
 170
 171     // keep read lock to receive updates from others
 172     return e;
 173 }
 174
 175 StoreEntry *
 176 Transients::findCollapsed(const sfileno index)
 177 {
 178     if (!map)
 179         return nullptr;
 180
 181     if (StoreEntry *oldE = locals->at(index)) {
 182         debugs(20, 5, "found " << *oldE << " at " << index << " in " << MapLabel);
 183         assert(oldE->mem_obj && oldE->mem_obj->xitTable.index == index);
 184         return oldE;
 185     }
 186
 187     debugs(20, 3, "no entry at " << index << " in " << MapLabel);
 188     return nullptr;
 189 }
 190
 191 void
 192 Transients::monitorIo(StoreEntry *e, const cache_key *key, const Store::IoStatus direction)
 193 {
 194     if (!e->hasTransients()) {
 195         addEntry(e, key, direction);
 196         assert(e->hasTransients());
 197     }
 198
 199     const auto index = e->mem_obj->xitTable.index;
 200     if (const auto old = locals->at(index)) {
 201         assert(old == e);
 202     } else {
 203         // We do not lock e because we do not want to prevent its destruction;
 204         // e is tied to us via mem_obj so we will know when it is destructed.
 205         locals->at(index) = e;
 206     }
 207 }
 208
 209 /// creates a new Transients entry
 210 void
 211 Transients::addEntry(StoreEntry *e, const cache_key *key, const Store::IoStatus direction)
 212 {
 213     assert(e);
 214     assert(e->mem_obj);
 215     assert(!e->hasTransients());
 216
 217     Must(map); // configured to track transients
 218
 219     if (direction == Store::ioWriting)
 220         return addWriterEntry(*e, key);
 221
 222     assert(direction == Store::ioReading);
 223     addReaderEntry(*e, key);
 224 }
 225
 226 /// addEntry() helper used for cache entry creators/writers
 227 void
 228 Transients::addWriterEntry(StoreEntry &e, const cache_key *key)
 229 {
 230     sfileno index = 0;
 231     const auto anchor = map->openForWriting(key, index);
 232     if (!anchor)
 233         throw TextException("writer collision", Here());
 234
 235     // set ASAP in hope to unlock the slot if something throws
 236     // and to provide index to such methods as hasWriter()
 237     e.mem_obj->xitTable.open(index, Store::ioWriting);
 238
 239     anchor->setKey(key);
 240     // allow reading and receive remote DELETE events, but do not switch to
 241     // the reading lock because transientReaders() callers want true readers
 242     map->startAppending(index);
 243 }
 244
 245 /// addEntry() helper used for cache readers
 246 /// readers do not modify the cache, but they must create a Transients entry
 247 void
 248 Transients::addReaderEntry(StoreEntry &e, const cache_key *key)
 249 {
 250     sfileno index = 0;
 251     const auto anchor = map->openOrCreateForReading(key, index);
 252     if (!anchor)
 253         throw TextException("reader collision", Here());
 254
 255     e.mem_obj->xitTable.open(index, Store::ioReading);
 256     // keep the entry locked (for reading) to receive remote DELETE events
 257 }
 258
 259 bool
 260 Transients::hasWriter(const StoreEntry &e)
 261 {
 262     if (!e.hasTransients())
 263         return false;
 264     return map->peekAtWriter(e.mem_obj->xitTable.index);
 265 }
 266
 267 void
 268 Transients::noteFreeMapSlice(const Ipc::StoreMapSliceId)
 269 {
 270     // TODO: we should probably find the entry being deleted and abort it
 271 }
 272
 273 void
 274 Transients::status(const StoreEntry &entry, Transients::EntryStatus &entryStatus) const
 275 {
 276     assert(map);
 277     assert(entry.hasTransients());
 278     const auto idx = entry.mem_obj->xitTable.index;
 279     const auto &anchor = isWriter(entry) ?
 280                          map->writeableEntry(idx) : map->readableEntry(idx);
 281     entryStatus.hasWriter = anchor.writing();
 282     entryStatus.waitingToBeFreed = anchor.waitingToBeFreed;
 283 }
 284
 285 void
 286 Transients::completeWriting(const StoreEntry &e)
 287 {
 288     debugs(20, 5, e);
 289     assert(e.hasTransients());
 290     assert(isWriter(e));
 291     map->switchWritingToReading(e.mem_obj->xitTable.index);
 292     e.mem_obj->xitTable.io = Store::ioReading;
 293     CollapsedForwarding::Broadcast(e);
 294 }
 295
 296 int
 297 Transients::readers(const StoreEntry &e) const
 298 {
 299     if (e.hasTransients()) {
 300         assert(map);
 301         return map->peekAtEntry(e.mem_obj->xitTable.index).lock.readers;
 302     }
 303     return 0;
 304 }
 305
 306 void
 307 Transients::evictCached(StoreEntry &e)
 308 {
 309     debugs(20, 5, e);
 310     if (e.hasTransients()) {
 311         const auto index = e.mem_obj->xitTable.index;
 312         if (map->freeEntry(index)) {
 313             // Delay syncCollapsed(index) which may end `e` wait for updates.
 314             // Calling it directly/here creates complex reentrant call chains.
 315             CollapsedForwarding::Broadcast(e, true);
 316         }
 317     } // else nothing to do because e must be private
 318 }
 319
 320 void
 321 Transients::evictIfFound(const cache_key *key)
 322 {
 323     if (!map)
 324         return;
 325
 326     const sfileno index = map->fileNoByKey(key);
 327     if (map->freeEntry(index))
 328         CollapsedForwarding::Broadcast(index, true);
 329 }
 330
 331 void
 332 Transients::disconnect(StoreEntry &entry)
 333 {
 334     debugs(20, 5, entry);
 335     if (entry.hasTransients()) {
 336         auto &xitTable = entry.mem_obj->xitTable;
 337         assert(map);
 338         if (isWriter(entry)) {
 339             // completeWriting() was not called, so there could be an active
 340             // Store writer out there, but we should not abortWriting() here
 341             // because another writer may have succeeded, making readers happy.
 342             // If none succeeded, the readers will notice the lack of writers.
 343             map->closeForWriting(xitTable.index);
 344             CollapsedForwarding::Broadcast(entry);
 345         } else {
 346             assert(isReader(entry));
 347             map->closeForReadingAndFreeIdle(xitTable.index);
 348         }
 349         locals->at(xitTable.index) = nullptr;
 350         xitTable.close();
 351     }
 352 }
 353
 354 /// calculates maximum number of entries we need to store and map
 355 int64_t
 356 Transients::EntryLimit()
 357 {
 358     return (UsingSmp() && Store::Controller::SmpAware()) ?
 359            Config.shared_transient_entries_limit : 0;
 360 }
 361
 362 bool
 363 Transients::markedForDeletion(const cache_key *key) const
 364 {
 365     assert(map);
 366     return map->markedForDeletion(key);
 367 }
 368
 369 bool
 370 Transients::isReader(const StoreEntry &e) const
 371 {
 372     return e.mem_obj && e.mem_obj->xitTable.io == Store::ioReading;
 373 }
 374
 375 bool
 376 Transients::isWriter(const StoreEntry &e) const
 377 {
 378     return e.mem_obj && e.mem_obj->xitTable.io == Store::ioWriting;
 379 }
 380
 381 /// initializes shared memory segment used by Transients
 382 class TransientsRr: public Ipc::Mem::RegisteredRunner
 383 {
 384 public:
 385     /* RegisteredRunner API */
 386     void useConfig() override;
 387     ~TransientsRr() override;
 388
 389 protected:
 390     void create() override;
 391
 392 private:
 393     TransientsMap::Owner *mapOwner = nullptr;
 394 };
 395
 396 DefineRunnerRegistrator(TransientsRr);
 397
 398 void
 399 TransientsRr::useConfig()
 400 {
 401     assert(Config.memShared.configured());
 402     Ipc::Mem::RegisteredRunner::useConfig();
 403 }
 404
 405 void
 406 TransientsRr::create()
 407 {
 408     const int64_t entryLimit = Transients::EntryLimit();
 409     if (entryLimit <= 0)
 410         return; // no SMP configured or a misconfiguration
 411
 412     Must(!mapOwner);
 413     mapOwner = TransientsMap::Init(MapLabel, entryLimit);
 414 }
 415
 416 TransientsRr::~TransientsRr()
 417 {
 418     delete mapOwner;
 419 }
 420