251//
252// Thread management and startup/shutdown:
253//
254// The network-processing threads are all part of a thread group
255// created by AppInit() or the Qt main() function.
256//
257// A clean exit happens when the SignalInterrupt object is triggered, which
258// makes the main thread's SignalInterrupt::wait() call return, and join all
259// other ongoing threads in the thread group to the main thread.
260// Shutdown() is then called to clean up database connections, and stop other
261// threads that should only be stopped after the main network-processing
262// threads have exited.
263//
264// Shutdown for Qt is very similar, only it uses a QTimer to detect
265// ShutdownRequested() getting set, and then does the normal Qt
266// shutdown thing.
267//
268
269bool ShutdownRequested(node::NodeContext& node)
270{
271    return bool{*Assert(node.shutdown_signal)};
272}
273
274#if HAVE_SYSTEM
275static void ShutdownNotify(const ArgsManager& args)
276{
277    std::vector<std::thread> threads;
278    for (const auto& cmd : args.GetArgs("-shutdownnotify")) {
279        threads.emplace_back(runCommand, cmd);
280    }
281    for (auto& t : threads) {
282        t.join();
283    }
284}
285#endif
286
287void Interrupt(NodeContext& node)
288{
289#if HAVE_SYSTEM
290    ShutdownNotify(*node.args);
291#endif
292    // Wake any threads that may be waiting for the tip to change.
293    if (node.notifications) WITH_LOCK(node.notifications->m_tip_block_mutex, node.notifications->m_tip_block_cv.notify_all());
294    InterruptHTTPServer();
295    InterruptHTTPRPC();
296    InterruptRPC();
297    InterruptREST();
298    if (node.tor_controller) {
299        node.tor_controller->Interrupt();
300    }
301    InterruptMapPort();
302    if (node.connman)
303        node.connman->Interrupt();
304    for (auto* index : node.indexes) {
305        index->Interrupt();
306    }
307}
308
309void Shutdown(NodeContext& node)
310{
311    static Mutex g_shutdown_mutex;
312    TRY_LOCK(g_shutdown_mutex, lock_shutdown);
313    if (!lock_shutdown) return;
314    LogInfo("Shutdown in progress...");
315    Assert(node.args);
316
317    /// Note: Shutdown() must be able to handle cases in which initialization failed part of the way,
318    /// for example if the data directory was found to be locked.
319    /// Be sure that anything that writes files or flushes caches only does this if the respective
320    /// module was initialized.
321    util::ThreadRename("shutoff");
322    if (node.mempool) node.mempool->AddTransactionsUpdated(1);
323
324    StopHTTPRPC();
325    StopREST();
326    StopRPC();
327    StopHTTPServer();
328    for (auto& client : node.chain_clients) {
329        try {
330            client->stop();
331        } catch (const ipc::Exception& e) {
332            LogDebug(BCLog::IPC, "Chain client did not disconnect cleanly: %s", e.what());
333            client.reset();
334        }
335    }
336    StopMapPort();
337
338    // Because these depend on each-other, we make sure that neither can be
339    // using the other before destroying them.
340    if (node.peerman && node.validation_signals) node.validation_signals->UnregisterValidationInterface(node.peerman.get());
341    if (node.connman) node.connman->Stop();
342
343    if (node.tor_controller) {
344        node.tor_controller->Join();
345        node.tor_controller.reset();
346    }
347
348    if (node.background_init_thread.joinable()) node.background_init_thread.join();
349    // After everything has been shut down, but before things get flushed, stop the
350    // the scheduler. After this point, SyncWithValidationInterfaceQueue() should not be called anymore
351    // as this would prevent the shutdown from completing.
352    if (node.scheduler) node.scheduler->stop();
353
354    // After the threads that potentially access these pointers have been stopped,
355    // destruct and reset all to nullptr.
356    node.peerman.reset();
357    node.connman.reset();
358    node.banman.reset();
359    node.addrman.reset();
360    node.netgroupman.reset();
361
362    if (node.mempool && node.mempool->GetLoadTried() && ShouldPersistMempool(*node.args)) {
363        DumpMempool(*node.mempool, MempoolPath(*node.args));
364    }
365
366    // FlushStateToDisk generates a ChainStateFlushed callback, which we should avoid missing
367    if (node.chainman) {
368        LOCK(cs_main);
369        for (const auto& chainstate : node.chainman->m_chainstates) {
370            if (chainstate->CanFlushToDisk()) {
371                chainstate->ForceFlushStateToDisk();
372            }
373        }
374    }
375
376    // After there are no more peers/RPC left to give us new data which may generate
377    // CValidationInterface callbacks, flush them...
378    if (node.validation_signals) node.validation_signals->FlushBackgroundCallbacks();
379
380    // Once callbacks drain, drop tracked transactions, save estimates, and unregister the estimator
381    if (node.fee_estimator_man) {
382        node.fee_estimator_man->ShutdownFlush();
383        if (node.validation_signals) {
384            node.validation_signals->UnregisterValidationInterface(node.fee_estimator_man.get());
385        }
386    }
387
388    // Stop and delete all indexes only after flushing background callbacks.
389    for (auto* index : node.indexes) index->Stop();
390    if (g_txindex) g_txindex.reset();
391    if (g_txospenderindex) g_txospenderindex.reset();
392    if (g_coin_stats_index) g_coin_stats_index.reset();
393    DestroyAllBlockFilterIndexes();
394    node.indexes.clear(); // all instances are nullptr now
395
396    // Callbacks queued by this final chainstate flush will not run during shutdown
397    if (node.chainman) {
398        LOCK(cs_main);
399        for (const auto& chainstate : node.chainman->m_chainstates) {
400            if (chainstate->CanFlushToDisk()) {
401                chainstate->ForceFlushStateToDisk();
402                chainstate->ResetCoinsViews();
403            }
404        }
405    }
406
407    // If any -ipcbind clients are still connected, disconnect them now so they
408    // do not block shutdown.
409    if (interfaces::Ipc* ipc = node.init->ipc()) {
410        ipc->disconnectIncoming();
411    }
412
413#ifdef ENABLE_ZMQ
414    if (g_zmq_notification_interface) {
415        if (node.validation_signals) node.validation_signals->UnregisterValidationInterface(g_zmq_notification_interface.get());
416        g_zmq_notification_interface.reset();
417    }
418#endif
419
420    node.chain_clients.clear();
421    if (node.validation_signals) {
422        node.validation_signals->UnregisterAllValidationInterfaces();
423    }
424    node.fee_estimator_man.reset();
425    node.mempool.reset();
426    node.chainman.reset();
427    node.validation_signals.reset();
428    node.scheduler.reset();
429    node.ecc_context.reset();
430    node.kernel.reset();
431
432    RemovePidFile(*node.args);
433
434    LogInfo("Shutdown done");
435}
436
437/**
438 * Signal handlers are very limited in what they are allowed to do.
439 * The execution context the handler is invoked in is not guaranteed,
440 * so we restrict handler operations to just touching variables:
441 */
442#ifndef WIN32
443static void HandleSIGTERM(int)
444{
445    // Return value is intentionally ignored because there is not a better way
446    // of handling this failure in a signal handler.
447    (void)(*Assert(g_shutdown))();
448}
449
450static void HandleSIGHUP(int)
451{
452    LogInstance().m_reopen_file = true;
453}
454#else
455static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType)
456{
457    if (!(*Assert(g_shutdown))()) {
458        LogError("Failed to send shutdown signal on Ctrl-C\n");
459        return false;
460    }
461    Sleep(INFINITE);
462    return true;
463}
464#endif
465
466#ifndef WIN32
467static void registerSignalHandler(int signal, void(*handler)(int))
468{
469    struct sigaction sa;
470    sa.sa_handler = handler;
471    sigemptyset(&sa.sa_mask);
472    sa.sa_flags = 0;
473    sigaction(signal, &sa, nullptr);
474}
475#endif
476
477void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc)
478{
479    SetupHelpOptions(argsman);
480    argsman.AddArg("-help-debug", "Print help message with debugging options and exit", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST); // server-only for now
481
482    init::AddLoggingArgs(argsman);
483
484    const auto defaultBaseParams = CreateBaseChainParams(ChainType::MAIN);
485    const auto testnetBaseParams = CreateBaseChainParams(ChainType::TESTNET);
486    const auto testnet4BaseParams = CreateBaseChainParams(ChainType::TESTNET4);
487    const auto signetBaseParams = CreateBaseChainParams(ChainType::SIGNET);
488    const auto regtestBaseParams = CreateBaseChainParams(ChainType::REGTEST);
489    const auto defaultChainParams = CreateChainParams(argsman, ChainType::MAIN);
490    const auto testnetChainParams = CreateChainParams(argsman, ChainType::TESTNET);
491    const auto testnet4ChainParams = CreateChainParams(argsman, ChainType::TESTNET4);
492    const auto signetChainParams = CreateChainParams(argsman, ChainType::SIGNET);
493    const auto regtestChainParams = CreateChainParams(argsman, ChainType::REGTEST);
494
495    // Hidden Options
496    std::vector<std::string> hidden_args = {
497        "-dbcrashratio", "-forcecompactdb",
498        // GUI args. These will be overwritten by SetupUIArgs for the GUI
499        "-choosedatadir", "-lang=<lang>", "-min", "-resetguisettings", "-splash", "-uiplatform"};
500