Migrated RegisteredRunners to a multi-action interface. Old generic two-action RegisteredRunners were good for handling paired create/destroy events, but not all main.cc events fit that model well. In fact, even the old runners implemented the destruction action for one event only (rrAfterConfig); all other runners implemented a single action. The adjusted API better supports runners that are interested in any number of the supported events. It also allows a single runner object to handle multiple events, which simplifies current code and may help with better [re]configuration handling in the future. Added startShutdown() and finishShutdown() events. The former will be needed for authentication module shutdown and more polished shutdown initiation code in general (patch pending). The latter is needed for final cleanup code that previously ran as the destruction action for rrAfterConfig. finishShutdown() also destroys all runners. Note that the master process in SMP mode does not run startShutdown because that process lacks the main loop and startShutdown() promises at least one main loop iteration (to help with clean connections closures, for example). Added syncConfig() event that will be needed for the standby pool implementation (patch pending) and future code that reacts to Squid configuration changes caused by reconfiguration. "after config" event is now called "use config" to better match verb+noun or action+object naming scheme. === modified file 'src/CollapsedForwarding.cc' --- src/CollapsedForwarding.cc 2014-01-27 05:27:41 +0000 +++ src/CollapsedForwarding.cc 2014-02-20 00:08:52 +0000 @@ -117,46 +117,46 @@ CollapsedForwarding::HandleNewData(const void CollapsedForwarding::HandleNotification(const Ipc::TypedMsgHdr &msg) { const int from = msg.getInt(); debugs(17, 7, "from " << from); assert(queue.get()); queue->clearReaderSignal(from); HandleNewData("after notification"); } /// initializes shared queue used by CollapsedForwarding class CollapsedForwardingRr: public Ipc::Mem::RegisteredRunner { public: /* RegisteredRunner API */ CollapsedForwardingRr(): owner(NULL) {} virtual ~CollapsedForwardingRr(); protected: - virtual void create(const RunnerRegistry &); - virtual void open(const RunnerRegistry &); + virtual void create(); + virtual void open(); private: Ipc::MultiQueue::Owner *owner; }; -RunnerRegistrationEntry(rrAfterConfig, CollapsedForwardingRr); +RunnerRegistrationEntry(CollapsedForwardingRr); -void CollapsedForwardingRr::create(const RunnerRegistry &) +void CollapsedForwardingRr::create() { Must(!owner); owner = Ipc::MultiQueue::Init(ShmLabel, Config.workers, 1, sizeof(CollapsedForwardingMsg), QueueCapacity); } -void CollapsedForwardingRr::open(const RunnerRegistry &) +void CollapsedForwardingRr::open() { CollapsedForwarding::Init(); } CollapsedForwardingRr::~CollapsedForwardingRr() { delete owner; } === modified file 'src/DiskIO/IpcIo/IpcIoFile.cc' --- src/DiskIO/IpcIo/IpcIoFile.cc 2014-01-27 05:27:41 +0000 +++ src/DiskIO/IpcIo/IpcIoFile.cc 2014-02-20 00:24:08 +0000 @@ -888,75 +888,69 @@ DiskerOpen(const String &path, int flags return false; } ++store_open_disk_fd; debugs(79,3, HERE << "rock db opened " << path << ": FD " << TheFile); return true; } static void DiskerClose(const String &path) { if (TheFile >= 0) { file_close(TheFile); debugs(79,3, HERE << "rock db closed " << path << ": FD " << TheFile); TheFile = -1; --store_open_disk_fd; } } /// reports our needs for shared memory pages to Ipc::Mem::Pages -class IpcIoClaimMemoryNeedsRr: public RegisteredRunner +/// and initializes shared memory segments used by IpcIoFile +class IpcIoRr: public Ipc::Mem::RegisteredRunner { public: /* RegisteredRunner API */ - virtual void run(const RunnerRegistry &r); + IpcIoRr(): owner(NULL) {} + virtual ~IpcIoRr(); + virtual void claimMemoryNeeds(); + +protected: + /* Ipc::Mem::RegisteredRunner API */ + virtual void create(); + +private: + Ipc::FewToFewBiQueue::Owner *owner; }; -RunnerRegistrationEntry(rrClaimMemoryNeeds, IpcIoClaimMemoryNeedsRr); +RunnerRegistrationEntry(IpcIoRr); void -IpcIoClaimMemoryNeedsRr::run(const RunnerRegistry &) +IpcIoRr::claimMemoryNeeds() { const int itemsCount = Ipc::FewToFewBiQueue::MaxItemsCount( ::Config.workers, ::Config.cacheSwap.n_strands, QueueCapacity); // the maximum number of shared I/O pages is approximately the // number of queue slots, we add a fudge factor to that to account // for corner cases where I/O pages are created before queue // limits are checked or destroyed long after the I/O is dequeued Ipc::Mem::NotePageNeed(Ipc::Mem::PageId::ioPage, static_cast(itemsCount * 1.1)); } -/// initializes shared memory segments used by IpcIoFile -class IpcIoRr: public Ipc::Mem::RegisteredRunner -{ -public: - /* RegisteredRunner API */ - IpcIoRr(): owner(NULL) {} - virtual ~IpcIoRr(); - -protected: - virtual void create(const RunnerRegistry &); - -private: - Ipc::FewToFewBiQueue::Owner *owner; -}; - -RunnerRegistrationEntry(rrAfterConfig, IpcIoRr); - -void IpcIoRr::create(const RunnerRegistry &) +void +IpcIoRr::create() { if (Config.cacheSwap.n_strands <= 0) return; Must(!owner); owner = Ipc::FewToFewBiQueue::Init(ShmLabel, Config.workers, 1, Config.cacheSwap.n_strands, 1 + Config.workers, sizeof(IpcIoMsg), QueueCapacity); } IpcIoRr::~IpcIoRr() { delete owner; } === modified file 'src/MemStore.cc' --- src/MemStore.cc 2014-01-01 19:20:49 +0000 +++ src/MemStore.cc 2014-02-20 00:25:20 +0000 @@ -729,110 +729,98 @@ MemStore::disconnect(StoreEntry &e) assert(mem_obj.memCache.io == MemObject::ioReading); map->closeForReading(mem_obj.memCache.index); mem_obj.memCache.index = -1; mem_obj.memCache.io = MemObject::ioDone; } } } /// calculates maximum number of entries we need to store and map int64_t MemStore::EntryLimit() { if (!Config.memShared || !Config.memMaxSize) return 0; // no memory cache configured const int64_t minEntrySize = Ipc::Mem::PageSize(); const int64_t entryLimit = Config.memMaxSize / minEntrySize; return entryLimit; } -/// reports our needs for shared memory pages to Ipc::Mem::Pages -class MemStoreClaimMemoryNeedsRr: public RegisteredRunner +/// reports our needs for shared memory pages to Ipc::Mem::Pages; +/// decides whether to use a shared memory cache or checks its configuration; +/// and initializes shared memory segments used by MemStore +class MemStoreRr: public Ipc::Mem::RegisteredRunner { public: /* RegisteredRunner API */ - virtual void run(const RunnerRegistry &r); + MemStoreRr(): spaceOwner(NULL), mapOwner(NULL) {} + virtual void finalizeConfig(); + virtual void claimMemoryNeeds(); + virtual void useConfig(); + virtual ~MemStoreRr(); + +protected: + /* Ipc::Mem::RegisteredRunner API */ + virtual void create(); + +private: + Ipc::Mem::Owner *spaceOwner; ///< free slices Owner + MemStoreMap::Owner *mapOwner; ///< primary map Owner }; -RunnerRegistrationEntry(rrClaimMemoryNeeds, MemStoreClaimMemoryNeedsRr); +RunnerRegistrationEntry(MemStoreRr); void -MemStoreClaimMemoryNeedsRr::run(const RunnerRegistry &) +MemStoreRr::claimMemoryNeeds() { Ipc::Mem::NotePageNeed(Ipc::Mem::PageId::cachePage, MemStore::EntryLimit()); } -/// decides whether to use a shared memory cache or checks its configuration -class MemStoreCfgRr: public ::RegisteredRunner -{ -public: - /* RegisteredRunner API */ - virtual void run(const RunnerRegistry &); -}; - -RunnerRegistrationEntry(rrFinalizeConfig, MemStoreCfgRr); - -void MemStoreCfgRr::run(const RunnerRegistry &r) +void +MemStoreRr::finalizeConfig() { // decide whether to use a shared memory cache if the user did not specify if (!Config.memShared.configured()) { Config.memShared.configure(Ipc::Atomic::Enabled() && Ipc::Mem::Segment::Enabled() && UsingSmp() && Config.memMaxSize > 0); } else if (Config.memShared && !Ipc::Atomic::Enabled()) { // bail if the user wants shared memory cache but we cannot support it fatal("memory_cache_shared is on, but no support for atomic operations detected"); } else if (Config.memShared && !Ipc::Mem::Segment::Enabled()) { fatal("memory_cache_shared is on, but no support for shared memory detected"); } else if (Config.memShared && !UsingSmp()) { debugs(20, DBG_IMPORTANT, "WARNING: memory_cache_shared is on, but only" " a single worker is running"); } } -/// initializes shared memory segments used by MemStore -class MemStoreRr: public Ipc::Mem::RegisteredRunner -{ -public: - /* RegisteredRunner API */ - MemStoreRr(): spaceOwner(NULL), mapOwner(NULL) {} - virtual void run(const RunnerRegistry &); - virtual ~MemStoreRr(); - -protected: - virtual void create(const RunnerRegistry &); - -private: - Ipc::Mem::Owner *spaceOwner; ///< free slices Owner - MemStoreMap::Owner *mapOwner; ///< primary map Owner -}; - -RunnerRegistrationEntry(rrAfterConfig, MemStoreRr); - -void MemStoreRr::run(const RunnerRegistry &r) +void +MemStoreRr::useConfig() { assert(Config.memShared.configured()); - Ipc::Mem::RegisteredRunner::run(r); + Ipc::Mem::RegisteredRunner::useConfig(); } -void MemStoreRr::create(const RunnerRegistry &) +void +MemStoreRr::create() { if (!Config.memShared) return; const int64_t entryLimit = MemStore::EntryLimit(); if (entryLimit <= 0) { if (Config.memMaxSize > 0) { debugs(20, DBG_IMPORTANT, "WARNING: mem-cache size is too small (" << (Config.memMaxSize / 1024.0) << " KB), should be >= " << (Ipc::Mem::PageSize() / 1024.0) << " KB"); } return; // no memory cache configured or a misconfiguration } Must(!spaceOwner); spaceOwner = shm_new(Ipc::Mem::PageStack)(SpaceLabel, SpacePoolId, entryLimit, sizeof(Ipc::Mem::PageId)); Must(!mapOwner); mapOwner = MemStoreMap::Init(MapLabel, entryLimit); === modified file 'src/Transients.cc' --- src/Transients.cc 2013-12-31 18:49:41 +0000 +++ src/Transients.cc 2014-02-20 00:20:36 +0000 @@ -369,57 +369,57 @@ Transients::disconnect(MemObject &mem_ob } } /// calculates maximum number of entries we need to store and map int64_t Transients::EntryLimit() { // TODO: we should also check whether any SMP-aware caching is configured if (!UsingSmp() || !Config.onoff.collapsed_forwarding) return 0; // no SMP collapsed forwarding possible or needed return 16*1024; // TODO: make configurable? } /// initializes shared memory segment used by Transients class TransientsRr: public Ipc::Mem::RegisteredRunner { public: /* RegisteredRunner API */ TransientsRr(): mapOwner(NULL) {} - virtual void run(const RunnerRegistry &); + virtual void useConfig(); virtual ~TransientsRr(); protected: - virtual void create(const RunnerRegistry &); + virtual void create(); private: TransientsMap::Owner *mapOwner; }; -RunnerRegistrationEntry(rrAfterConfig, TransientsRr); +RunnerRegistrationEntry(TransientsRr); void -TransientsRr::run(const RunnerRegistry &r) +TransientsRr::useConfig() { assert(Config.memShared.configured()); - Ipc::Mem::RegisteredRunner::run(r); + Ipc::Mem::RegisteredRunner::useConfig(); } void -TransientsRr::create(const RunnerRegistry &) +TransientsRr::create() { if (!Config.onoff.collapsed_forwarding) return; const int64_t entryLimit = Transients::EntryLimit(); if (entryLimit <= 0) return; // no SMP configured or a misconfiguration Must(!mapOwner); mapOwner = TransientsMap::Init(MapLabel, entryLimit); } TransientsRr::~TransientsRr() { delete mapOwner; } === modified file 'src/base/RunnersRegistry.cc' --- src/base/RunnersRegistry.cc 2012-01-20 18:55:04 +0000 +++ src/base/RunnersRegistry.cc 2014-02-20 00:57:34 +0000 @@ -1,57 +1,45 @@ #include "squid.h" #include "base/RunnersRegistry.h" -#include -#include +#include -typedef std::list Runners; -typedef std::map Registries; +/// a collection of unique runners, in no particular order +typedef std::set Runners; +/// all known runners +static Runners *TheRunners = NULL; -/// all known registries -static Registries *TheRegistries = NULL; - -/// returns the requested runners list, initializing structures as needed +/// safely returns registered runners, initializing structures as needed static Runners & -GetRunners(const RunnerRegistry ®istryId) +GetRunners() { - if (!TheRegistries) - TheRegistries = new Registries; - - if (TheRegistries->find(registryId) == TheRegistries->end()) - (*TheRegistries)[registryId] = new Runners; - - return *(*TheRegistries)[registryId]; + if (!TheRunners) + TheRunners = new Runners; + return *TheRunners; } int -RegisterRunner(const RunnerRegistry ®istryId, RegisteredRunner *rr) +RegisterRunner(RegisteredRunner *rr) { - Runners &runners = GetRunners(registryId); - runners.push_back(rr); + Runners &runners = GetRunners(); + runners.insert(rr); return runners.size(); } -int -ActivateRegistered(const RunnerRegistry ®istryId) +void +RunRegistered(const RegisteredRunner::Method &m) { - Runners &runners = GetRunners(registryId); + Runners &runners = GetRunners(); typedef Runners::iterator RRI; for (RRI i = runners.begin(); i != runners.end(); ++i) - (*i)->run(registryId); - return runners.size(); -} + ((*i)->*m)(); -void -DeactivateRegistered(const RunnerRegistry ®istryId) -{ - Runners &runners = GetRunners(registryId); - while (!runners.empty()) { - delete runners.back(); - runners.pop_back(); + if (m == &RegisteredRunner::finishShutdown) { + delete TheRunners; + TheRunners = NULL; } } bool UseThisStatic(const void *) { return true; } === modified file 'src/base/RunnersRegistry.h' --- src/base/RunnersRegistry.h 2012-08-28 13:00:30 +0000 +++ src/base/RunnersRegistry.h 2014-02-20 02:18:36 +0000 @@ -1,71 +1,95 @@ #ifndef SQUID_BASE_RUNNERSREGISTRY_H #define SQUID_BASE_RUNNERSREGISTRY_H /** - * This API allows virtually any module to register with a well-known registry, - * be activated by some central processor at some registry-specific time, and - * be deactiveated by some central processor at some registry-specific time. + * This API allows virtually any module to register its interest in receiving + * notification about initial configuration availability, configuration changes + * and other critical events in Squid lifetime without exposing the notifier + * to the details of the module. * * For example, main.cc may activate registered I/O modules after parsing - * squid.conf and deactivate them before exiting. + * squid.conf and deactivate them before exiting, all without knowing what + * those I/O modules really are. * * A module in this context is code providing a functionality or service to the - * rest of Squid, such as src/DiskIO/Blocking, src/fs/ufs, or Cache Manager. A - * module must declare a RegisteredRunner child class to implement activation and - * deactivation logic using the run() method and destructor, respectively. + * rest of Squid, such as src/DiskIO/Blocking, src/fs/ufs, or Cache Manager. To + * receive notifications, a module must declare a RegisteredRunner child class + * and implement the methods corresponding to the events the module is + * interested in. * - * This API allows the registry to determine the right [de]activation time for - * each group of similar modules, without knowing any module specifics. + * The order of events is documented in this header (where applicable), but + * the order in which runners are notified about a given event is undefined. + * If a specific notification order is required, split the event into two or + * more related event(s), documenting their relative order here. * */ -/// well-known registries -typedef enum { - /// Managed by main.cc. Activated after parsing squid.conf and - /// deactivated before freeing configuration-related memory or exit()-ing. +/// a runnable registrant API +/// kids must override [only] the methods they are interested in +class RegisteredRunner +{ +public: + /* Related methods below are declared in their calling order */ + + /* Configuration events */ + + /// Called after parsing squid.conf. /// Meant for setting configuration options that depend on other /// configuration options and were not explicitly configured. - rrFinalizeConfig, + virtual void finalizeConfig() {} - /// Managed by main.cc. Activated after rrFinalizeConfig and - /// deactivated before rrFinalizeConfig. Meant for announcing - /// memory reservations before memory is allocated. - rrClaimMemoryNeeds, - - /// Managed by main.cc. Activated after rrClaimMemoryNeeds and - /// deactivated before rrClaimMemoryNeeds. Meant for activating - /// modules and features based on the finalized configuration. - rrAfterConfig, + /// Called after finalizeConfig(). + /// Meant for announcing memory reservations before memory is allocated. + virtual void claimMemoryNeeds() {} - rrEnd ///< not a real registry, just a label to mark the end of enum -} RunnerRegistry; + /// Called after claimMemoryNeeds(). + /// Meant for activating modules and features using a finalized + /// configuration with known memory requirements. + virtual void useConfig() {} -/// a runnable registrant API -class RegisteredRunner -{ -public: - // called when this runner's registry is deactivated + /* Reconfiguration events */ + + /// Called after parsing squid.conf during reconfiguration. + /// Meant for adjusting the module state based on configuration changes. + virtual void syncConfig() {} + + /* Shutdown events */ + + /// Called after receiving a shutdown request and before stopping the main + /// loop. At least one main loop iteration is guaranteed after this call. + /// Meant for cleanup and state saving that may require other modules. + virtual void startShutdown() {} + + /// Called after stopping the main loop. + /// Meant for quick/basic cleanup that does not require any other modules. virtual ~RegisteredRunner() {} + /// exists to simplify caller interface; override the destructor instead + void finishShutdown() { delete this; } + + /// a pointer to one of the above notification methods + typedef void (RegisteredRunner::*Method)(); - // called when this runner's registry is activated - virtual void run(const RunnerRegistry &r) = 0; }; /// registers a given runner with the given registry and returns registry count -int RegisterRunner(const RunnerRegistry ®istry, RegisteredRunner *rr); +int RegisterRunner(RegisteredRunner *rr); -/// calls run() methods of all runners in the given registry -int ActivateRegistered(const RunnerRegistry ®istry); -/// deletes all runners in the given registry -void DeactivateRegistered(const RunnerRegistry ®istry); +/// Calls a given method of all runners. +/// All runners are destroyed after the finishShutdown() call. +void RunRegistered(const RegisteredRunner::Method &m); + +/// convenience macro to describe/debug the caller and the method being called +#define RunRegisteredHere(m) \ + debugs(1, 2, "running " # m); \ + RunRegistered(&m) /// convenience function to "use" an otherwise unreferenced static variable bool UseThisStatic(const void *); /// convenience macro: register one RegisteredRunner kid as early as possible -#define RunnerRegistrationEntry(Registry, Who) \ - static const bool Who ## _RegisteredWith_ ## Registry = \ - RegisterRunner(Registry, new Who) > 0 && \ - UseThisStatic(& Who ## _RegisteredWith_ ## Registry); +#define RunnerRegistrationEntry(Who) \ + static const bool Who ## _Registered_ = \ + RegisterRunner(new Who) > 0 && \ + UseThisStatic(& Who ## _Registered_); #endif /* SQUID_BASE_RUNNERSREGISTRY_H */ === modified file 'src/cache_cf.cc' --- src/cache_cf.cc 2014-02-10 16:39:10 +0000 +++ src/cache_cf.cc 2014-02-20 00:33:30 +0000 @@ -4589,48 +4589,49 @@ static void dump_sslproxy_cert_sign(Stor } static void free_sslproxy_cert_sign(sslproxy_cert_sign **cert_sign) { while (*cert_sign) { sslproxy_cert_sign *cs = *cert_sign; *cert_sign = cs->next; if (cs->aclList) aclDestroyAclList(&cs->aclList); safe_free(cs); } } class sslBumpCfgRr: public ::RegisteredRunner { public: static Ssl::BumpMode lastDeprecatedRule; /* RegisteredRunner API */ - virtual void run(const RunnerRegistry &); + virtual void finalizeConfig(); }; Ssl::BumpMode sslBumpCfgRr::lastDeprecatedRule = Ssl::bumpEnd; -RunnerRegistrationEntry(rrFinalizeConfig, sslBumpCfgRr); +RunnerRegistrationEntry(sslBumpCfgRr); -void sslBumpCfgRr::run(const RunnerRegistry &r) +void +sslBumpCfgRr::finalizeConfig() { if (lastDeprecatedRule != Ssl::bumpEnd) { assert( lastDeprecatedRule == Ssl::bumpClientFirst || lastDeprecatedRule == Ssl::bumpNone); static char buf[1024]; if (lastDeprecatedRule == Ssl::bumpClientFirst) { strcpy(buf, "ssl_bump deny all"); debugs(3, DBG_CRITICAL, "WARNING: auto-converting deprecated implicit " "\"ssl_bump deny all\" to \"ssl_bump none all\". New ssl_bump configurations " "must not use implicit rules. Update your ssl_bump rules."); } else { strcpy(buf, "ssl_bump allow all"); debugs(3, DBG_CRITICAL, "SECURITY NOTICE: auto-converting deprecated implicit " "\"ssl_bump allow all\" to \"ssl_bump client-first all\" which is usually " "inferior to the newer server-first bumping mode. New ssl_bump" " configurations must not use implicit rules. Update your ssl_bump rules."); } parse_line(buf); } } === modified file 'src/client_db.cc' --- src/client_db.cc 2014-02-08 13:36:42 +0000 +++ src/client_db.cc 2014-02-20 00:14:03 +0000 @@ -107,46 +107,47 @@ clientdbAdd(const Ip::Address &addr) if ((statCounter.client_http.clients > max_clients) && !cleanup_running && cleanup_scheduled < 2) { ++cleanup_scheduled; eventAdd("client_db garbage collector", clientdbScheduledGC, NULL, 90, 0); } return c; } static void clientdbInit(void) { if (client_table) return; client_table = hash_create((HASHCMP *) strcmp, CLIENT_DB_HASH_SIZE, hash_string); } class ClientDbRr: public RegisteredRunner { public: - virtual void run(const RunnerRegistry &); + /* RegisteredRunner API */ + virtual void useConfig(); }; -RunnerRegistrationEntry(rrAfterConfig, ClientDbRr); +RunnerRegistrationEntry(ClientDbRr); void -ClientDbRr::run(const RunnerRegistry &r) +ClientDbRr::useConfig() { clientdbInit(); Mgr::RegisterAction("client_list", "Cache Client List", clientdbDump, 0, 1); } #if USE_DELAY_POOLS /* returns ClientInfo for given IP addr Returns NULL if no such client (or clientdb turned off) (it is assumed that clientdbEstablished will be called before and create client record if needed) */ ClientInfo * clientdbGetInfo(const Ip::Address &addr) { char key[MAX_IPSTRLEN]; ClientInfo *c; if (!Config.onoff.client_db) return NULL; addr.toStr(key,MAX_IPSTRLEN); === modified file 'src/fs/rock/RockSwapDir.cc' --- src/fs/rock/RockSwapDir.cc 2013-12-31 18:49:41 +0000 +++ src/fs/rock/RockSwapDir.cc 2014-02-19 23:44:01 +0000 @@ -987,44 +987,44 @@ Rock::SwapDir::statfs(StoreEntry &e) con const char * Rock::SwapDir::inodeMapPath() const { static String inodesPath; inodesPath = path; inodesPath.append("_inodes"); return inodesPath.termedBuf(); } const char * Rock::SwapDir::freeSlotsPath() const { static String spacesPath; spacesPath = path; spacesPath.append("_spaces"); return spacesPath.termedBuf(); } namespace Rock { -RunnerRegistrationEntry(rrAfterConfig, SwapDirRr); +RunnerRegistrationEntry(SwapDirRr); } -void Rock::SwapDirRr::create(const RunnerRegistry &) +void Rock::SwapDirRr::create() { Must(mapOwners.empty() && freeSlotsOwners.empty()); for (int i = 0; i < Config.cacheSwap.n_configured; ++i) { if (const Rock::SwapDir *const sd = dynamic_cast(INDEXSD(i))) { const int64_t capacity = sd->entryLimitAllowed(); SwapDir::DirMap::Owner *const mapOwner = SwapDir::DirMap::Init(sd->inodeMapPath(), capacity); mapOwners.push_back(mapOwner); // TODO: somehow remove pool id and counters from PageStack? Ipc::Mem::Owner *const freeSlotsOwner = shm_new(Ipc::Mem::PageStack)(sd->freeSlotsPath(), i+1, capacity, sizeof(DbCellHeader)); freeSlotsOwners.push_back(freeSlotsOwner); // TODO: add method to initialize PageStack with no free pages while (true) { Ipc::Mem::PageId pageId; === modified file 'src/fs/rock/RockSwapDir.h' --- src/fs/rock/RockSwapDir.h 2014-02-10 16:39:10 +0000 +++ src/fs/rock/RockSwapDir.h 2014-02-19 23:44:28 +0000 @@ -126,30 +126,30 @@ private: DiskIOStrategy *io; RefCount theFile; ///< cache storage for this cache_dir Ipc::Mem::Pointer freeSlots; ///< all unused slots Ipc::Mem::PageId *waitingForPage; ///< one-page cache for a "hot" free slot /* configurable options */ DiskFile::Config fileConfig; ///< file-level configuration options static const int64_t HeaderSize; ///< on-disk db header size }; /// initializes shared memory segments used by Rock::SwapDir class SwapDirRr: public Ipc::Mem::RegisteredRunner { public: /* ::RegisteredRunner API */ virtual ~SwapDirRr(); protected: /* Ipc::Mem::RegisteredRunner API */ - virtual void create(const RunnerRegistry &); + virtual void create(); private: std::vector mapOwners; std::vector< Ipc::Mem::Owner *> freeSlotsOwners; }; } // namespace Rock #endif /* SQUID_FS_ROCK_SWAP_DIR_H */ === modified file 'src/ipc/mem/Pages.cc' --- src/ipc/mem/Pages.cc 2013-10-25 00:13:46 +0000 +++ src/ipc/mem/Pages.cc 2014-02-19 23:57:59 +0000 @@ -73,64 +73,64 @@ Ipc::Mem::NotePageNeed(const int purpose } size_t Ipc::Mem::PageLevel() { return ThePagePool ? ThePagePool->level() : 0; } size_t Ipc::Mem::PageLevel(const int purpose) { return ThePagePool ? ThePagePool->level(purpose) : 0; } /// initializes shared memory pages class SharedMemPagesRr: public Ipc::Mem::RegisteredRunner { public: /* RegisteredRunner API */ SharedMemPagesRr(): owner(NULL) {} - virtual void run(const RunnerRegistry &); - virtual void create(const RunnerRegistry &); - virtual void open(const RunnerRegistry &); + virtual void useConfig(); + virtual void create(); + virtual void open(); virtual ~SharedMemPagesRr(); private: Ipc::Mem::PagePool::Owner *owner; }; -RunnerRegistrationEntry(rrAfterConfig, SharedMemPagesRr); +RunnerRegistrationEntry(SharedMemPagesRr); void -SharedMemPagesRr::run(const RunnerRegistry &r) +SharedMemPagesRr::useConfig() { if (Ipc::Mem::PageLimit() <= 0) return; - Ipc::Mem::RegisteredRunner::run(r); + Ipc::Mem::RegisteredRunner::useConfig(); } void -SharedMemPagesRr::create(const RunnerRegistry &) +SharedMemPagesRr::create() { Must(!owner); owner = Ipc::Mem::PagePool::Init(PagePoolId, Ipc::Mem::PageLimit(), Ipc::Mem::PageSize()); } void -SharedMemPagesRr::open(const RunnerRegistry &) +SharedMemPagesRr::open() { Must(!ThePagePool); ThePagePool = new Ipc::Mem::PagePool(PagePoolId); } SharedMemPagesRr::~SharedMemPagesRr() { if (!UsingSmp()) return; delete ThePagePool; ThePagePool = NULL; delete owner; } === modified file 'src/ipc/mem/Segment.cc' --- src/ipc/mem/Segment.cc 2012-09-01 14:38:36 +0000 +++ src/ipc/mem/Segment.cc 2014-02-19 23:54:15 +0000 @@ -262,38 +262,38 @@ Ipc::Mem::Segment::open() theSize = segment.theSize; debugs(54, 3, HERE << "opened " << theName << " fake segment: " << theSize); } void Ipc::Mem::Segment::checkSupport(const char *const context) { if (!Enabled()) { debugs(54, 5, HERE << context << ": True shared memory segments are not supported. " "Cannot fake shared segments in SMP config."); fatalf("Ipc::Mem::Segment: Cannot fake shared segments in SMP config (%s)\n", context); } } #endif // HAVE_SHM void -Ipc::Mem::RegisteredRunner::run(const RunnerRegistry &r) +Ipc::Mem::RegisteredRunner::useConfig() { // If Squid is built with real segments, we create() real segments // in the master process only. Otherwise, we create() fake // segments in each worker process. We assume that only workers // need and can work with fake segments. #if HAVE_SHM if (IamMasterProcess()) #else if (IamWorkerProcess()) #endif - create(r); + create(); // we assume that master process does not need shared segments // unless it is also a worker if (!InDaemonMode() || !IamMasterProcess()) - open(r); + open(); } === modified file 'src/ipc/mem/Segment.h' --- src/ipc/mem/Segment.h 2012-09-01 14:38:36 +0000 +++ src/ipc/mem/Segment.h 2014-02-19 23:45:16 +0000 @@ -55,35 +55,35 @@ private: #else // HAVE_SHM void checkSupport(const char *const context); #endif // HAVE_SHM const String theName; ///< shared memory segment file name void *theMem; ///< pointer to mmapped shared memory segment off_t theSize; ///< shared memory segment size off_t theReserved; ///< the total number of reserve()d bytes bool doUnlink; ///< whether the segment should be unlinked on destruction }; /// Base class for runners that create and open shared memory segments. /// First may run create() method and then open(). class RegisteredRunner: public ::RegisteredRunner { public: /* RegisteredRunner API */ - virtual void run(const RunnerRegistry &r); + virtual void useConfig(); protected: /// called when the runner should create a new memory segment - virtual void create(const RunnerRegistry &) = 0; + virtual void create() = 0; /// called when the runner should open a previously created segment, /// not needed if segments are opened in constructor or init methods - virtual void open(const RunnerRegistry &) {} + virtual void open() {} }; } // namespace Mem } // namespace Ipc #endif /* SQUID_IPC_MEM_SEGMENT_H */ === modified file 'src/main.cc' --- src/main.cc 2014-01-24 01:57:15 +0000 +++ src/main.cc 2014-02-20 01:35:19 +0000 @@ -257,40 +257,42 @@ SignalEngine::checkEvents(int timeout) } void SignalEngine::doShutdown(time_t wait) { debugs(1, DBG_IMPORTANT, "Preparing for shutdown after " << statCounter.client_http.requests << " requests"); debugs(1, DBG_IMPORTANT, "Waiting " << wait << " seconds for active connections to finish"); shutting_down = 1; #if USE_WIN32_SERVICE WIN32_svcstatusupdate(SERVICE_STOP_PENDING, (wait + 1) * 1000); #endif /* run the closure code which can be shared with reconfigure */ serverConnectionsClose(); #if USE_AUTH /* detach the auth components (only do this on full shutdown) */ Auth::Scheme::FreeAll(); #endif + + RunRegisteredHere(RegisteredRunner::startShutdown); eventAdd("SquidShutdown", &StopEventLoop, this, (double) (wait + 1), 1, false); } static void usage(void) { fprintf(stderr, "Usage: %s [-cdhvzCFNRVYX] [-n name] [-s | -l facility] [-f config-file] [-[au] port] [-k signal]" #if USE_WIN32_SERVICE "[-ir] [-O CommandLine]" #endif "\n" " -a port Specify HTTP port number (default: %d).\n" " -d level Write debugging to stderr also.\n" " -f file Use given config-file instead of\n" " %s\n" " -h Print help message.\n" #if USE_WIN32_SERVICE " -i Installs as a Windows Service (see -n option).\n" #endif @@ -787,40 +789,42 @@ mainReconfigureFinish(void *) errorClean(); enter_suid(); /* root to read config file */ // we may have disabled the need for PURGE if (Config2.onoff.enable_purge) Config2.onoff.enable_purge = 2; // parse the config returns a count of errors encountered. const int oldWorkers = Config.workers; if ( parseConfigFile(ConfigFile) != 0) { // for now any errors are a fatal condition... self_destruct(); } if (oldWorkers != Config.workers) { debugs(1, DBG_CRITICAL, "WARNING: Changing 'workers' (from " << oldWorkers << " to " << Config.workers << ") requires a full restart. It has been ignored by reconfigure."); Config.workers = oldWorkers; } + RunRegisteredHere(RegisteredRunner::syncConfig); + if (IamPrimaryProcess()) CpuAffinityCheck(); CpuAffinityReconfigure(); setUmask(Config.umask); Mem::Report(); setEffectiveUser(); _db_init(Debug::cache_log, Debug::debugOptions); ipcache_restart(); /* clear stuck entries */ fqdncache_restart(); /* sigh, fqdncache too */ parseEtcHosts(); errorInitialize(); /* reload error pages */ accessLogInit(); #if USE_LOADABLE_MODULES LoadableModulesConfigure(Config.loadable_module_names); #endif #if USE_ADAPTATION bool enableAdaptation = false; @@ -1426,43 +1430,43 @@ SquidMain(int argc, char **argv) return 0; #endif /* send signal to running copy and exit */ if (opt_send_signal != -1) { /* chroot if configured to run inside chroot */ mainSetCwd(); if (Config.chroot_dir) { no_suid(); } else { leave_suid(); } sendSignal(); /* NOTREACHED */ } debugs(1,2, HERE << "Doing post-config initialization\n"); leave_suid(); - ActivateRegistered(rrFinalizeConfig); - ActivateRegistered(rrClaimMemoryNeeds); - ActivateRegistered(rrAfterConfig); + RunRegisteredHere(RegisteredRunner::finalizeConfig); + RunRegisteredHere(RegisteredRunner::claimMemoryNeeds); + RunRegisteredHere(RegisteredRunner::useConfig); enter_suid(); if (!opt_no_daemon && Config.workers > 0) watch_child(argv); if (opt_create_swap_dirs) { /* chroot if configured to run inside chroot */ mainSetCwd(); setEffectiveUser(); debugs(0, DBG_CRITICAL, "Creating missing swap directories"); Store::Root().create(); return 0; } if (IamPrimaryProcess()) CpuAffinityCheck(); CpuAffinityInit(); @@ -1787,43 +1791,43 @@ watch_child(char *argv[]) syslog(LOG_NOTICE, "Squid Parent: %s process %d exited", kid->name().termedBuf(), kid->getPid()); } if (kid->hopeless()) { syslog(LOG_NOTICE, "Squid Parent: %s process %d will not" " be restarted due to repeated, frequent failures", kid->name().termedBuf(), kid->getPid()); } } else { syslog(LOG_NOTICE, "Squid Parent: unknown child process %d exited", pid); } #if _SQUID_NEXT_ } while ((pid = wait3(&status, WNOHANG, NULL)) > 0); #else } while ((pid = waitpid(-1, &status, WNOHANG)) > 0); #endif if (!TheKids.someRunning() && !TheKids.shouldRestartSome()) { leave_suid(); - DeactivateRegistered(rrAfterConfig); - DeactivateRegistered(rrClaimMemoryNeeds); - DeactivateRegistered(rrFinalizeConfig); + // XXX: Master process has no main loop and, hence, should not call + // RegisteredRunner::startShutdown which promises a loop iteration. + RunRegisteredHere(RegisteredRunner::finishShutdown); enter_suid(); if (TheKids.someSignaled(SIGINT) || TheKids.someSignaled(SIGTERM)) { syslog(LOG_ALERT, "Exiting due to unexpected forced shutdown"); exit(1); } if (TheKids.allHopeless()) { syslog(LOG_ALERT, "Exiting due to repeated, frequent failures"); exit(1); } exit(0); } squid_signal(SIGINT, SIG_DFL, SA_RESTART); sleep(3); } /* NOTREACHED */ @@ -1885,77 +1889,76 @@ SquidShutdown() authenticateReset(); #endif #if USE_WIN32_SERVICE WIN32_svcstatusupdate(SERVICE_STOP_PENDING, 10000); #endif Store::Root().sync(); /* Flush pending object writes/unlinks */ unlinkdClose(); /* after sync/flush. NOP if !USE_UNLINKD */ storeDirWriteCleanLogs(0); PrintRusage(); dumpMallocStats(); Store::Root().sync(); /* Flush log writes */ storeLogClose(); accessLogClose(); Store::Root().sync(); /* Flush log close */ StoreFileSystem::FreeAllFs(); DiskIOModule::FreeAllModules(); - DeactivateRegistered(rrAfterConfig); - DeactivateRegistered(rrClaimMemoryNeeds); - DeactivateRegistered(rrFinalizeConfig); #if LEAK_CHECK_MODE && 0 /* doesn't work at the moment */ configFreeMemory(); storeFreeMemory(); /*stmemFreeMemory(); */ netdbFreeMemory(); ipcacheFreeMemory(); fqdncacheFreeMemory(); asnFreeMemory(); clientdbFreeMemory(); httpHeaderCleanModule(); statFreeMemory(); eventFreeMemory(); mimeFreeMemory(); errorClean(); #endif #if !XMALLOC_TRACE if (opt_no_daemon) { file_close(0); file_close(1); file_close(2); } #endif // clear StoreController Store::Root(NULL); fdDumpOpen(); comm_exit(); memClean(); + RunRegisteredHere(RegisteredRunner::finishShutdown); + #if XMALLOC_TRACE xmalloc_find_leaks(); debugs(1, DBG_CRITICAL, "Memory used after shutdown: " << xmalloc_total); #endif #if MEM_GEN_TRACE log_trace_done(); #endif if (IamPrimaryProcess()) { if (Config.pidFilename && strcmp(Config.pidFilename, "none") != 0) { enter_suid(); safeunlink(Config.pidFilename, 0); leave_suid(); } } === modified file 'src/ssl/support.cc' --- src/ssl/support.cc 2014-02-08 13:36:42 +0000 +++ src/ssl/support.cc 2014-02-20 00:08:09 +0000 @@ -1822,56 +1822,56 @@ Ssl::initialize_session_cache() } for (AnyP::PortCfg *s = ::Config.Sockaddr.http; s; s = s->next) { if (s->staticSslContext.get() != NULL) setSessionCallbacks(s->staticSslContext.get()); } } void destruct_session_cache() { delete SslSessionCache; } /// initializes shared memory segments used by MemStore class SharedSessionCacheRr: public Ipc::Mem::RegisteredRunner { public: /* RegisteredRunner API */ SharedSessionCacheRr(): owner(NULL) {} - virtual void run(const RunnerRegistry &); + virtual void useConfig(); virtual ~SharedSessionCacheRr(); protected: - virtual void create(const RunnerRegistry &); + virtual void create(); private: Ipc::MemMap::Owner *owner; }; -RunnerRegistrationEntry(rrAfterConfig, SharedSessionCacheRr); +RunnerRegistrationEntry(SharedSessionCacheRr); void -SharedSessionCacheRr::run(const RunnerRegistry &r) +SharedSessionCacheRr::useConfig() { - Ipc::Mem::RegisteredRunner::run(r); + Ipc::Mem::RegisteredRunner::useConfig(); } void -SharedSessionCacheRr::create(const RunnerRegistry &) +SharedSessionCacheRr::create() { if (!isSslServer()) //no need to configure ssl session cache. return; int items; items = Config.SSL.sessionCacheSize / sizeof(Ipc::MemMap::Slot); if (items) owner = Ipc::MemMap::Init(SslSessionCacheName, items); } SharedSessionCacheRr::~SharedSessionCacheRr() { delete owner; } #endif /* USE_SSL */ === modified file 'src/tests/testRock.cc' --- src/tests/testRock.cc 2014-02-08 13:36:42 +0000 +++ src/tests/testRock.cc 2014-02-20 02:35:21 +0000 @@ -65,55 +65,56 @@ testRock::setUp() commonInit(); char *path=xstrdup(TESTDIR); char *config_line=xstrdup("10 max-size=16384"); ConfigParser::SetCfgLine(config_line); store->parse(0, path); store_maxobjsize = 1024*1024*2; safe_free(path); safe_free(config_line); /* ok, ready to create */ store->create(); rr = new Rock::SwapDirRr; - rr->run(rrAfterConfig); + rr->useConfig(); } void testRock::tearDown() { CPPUNIT_NS::TestFixture::tearDown(); Store::Root(NULL); store = NULL; free_cachedir(&Config.cacheSwap); - delete rr; + rr->finishShutdown(); // deletes rr + rr = NULL; // TODO: do this once, or each time. // safe_free(Config.replPolicy->type); // delete Config.replPolicy; if (0 > system ("rm -rf " TESTDIR)) throw std::runtime_error("Failed to clean test work directory"); } void testRock::commonInit() { static bool inited = false; if (inited) return; StoreFileSystem::SetupAllFs(); Config.Store.avgObjectSize = 1024;