Starting and stopping a Bitcoin Core node

2001    for (auto index : node.indexes) if (!index->Init()) return false;
2002
2003    // ********************************************************* Step 9: load wallet
2004    for (const auto& client : node.chain_clients) {
2005        if (!client->load()) {
2006            return false;
2007        }
2008    }
2009
2010    // ********************************************************* Step 10: data directory maintenance
2011
2012    // if pruning, perform the initial blockstore prune
2013    // after any wallet rescanning has taken place.
2014    if (chainman.m_blockman.IsPruneMode()) {
2015        if (chainman.m_blockman.m_blockfiles_indexed) {
2016            LOCK(cs_main);
2017            for (const auto& chainstate : chainman.m_chainstates) {
2018                uiInterface.InitMessage(_("Pruning blockstore…"));
2019                chainstate->PruneAndFlush();
2020            }
2021        }
2022    } else {
2023        // Prior to setting NODE_NETWORK, check if we can provide historical blocks.
2024        if (!WITH_LOCK(chainman.GetMutex(), return chainman.HistoricalChainstate())) {
2025            LogInfo("Setting NODE_NETWORK in non-prune mode");
2026            g_local_services = ServiceFlags(g_local_services | NODE_NETWORK);
2027        } else {
2028            LogInfo("Running node in NODE_NETWORK_LIMITED mode until snapshot background sync completes");
2029        }
2030    }
2031
2032    // ********************************************************* Step 11: import blocks
2033
2034    if (!CheckDiskSpace(args.GetDataDirNet())) {
2035        InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(args.GetDataDirNet()))));
2036        return false;
2037    }
2038    if (!CheckDiskSpace(args.GetBlocksDirPath())) {
2039        InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(args.GetBlocksDirPath()))));
2040        return false;
2041    }
2042
2043    int chain_active_height = WITH_LOCK(cs_main, return chainman.ActiveChain().Height());
2044
2045    // On first startup, warn on low block storage space
2046    if (!do_reindex && !do_reindex_chainstate && chain_active_height <= 1) {
2047        uint64_t assumed_chain_bytes{chainparams.AssumedBlockchainSize() * 1_GiB};
2048        uint64_t additional_bytes_needed{
2049            chainman.m_blockman.IsPruneMode() ?
2050                std::min(chainman.m_blockman.GetPruneTarget(), assumed_chain_bytes) :
2051                assumed_chain_bytes};
2052
2053        if (!CheckDiskSpace(args.GetBlocksDirPath(), additional_bytes_needed)) {
2054            InitWarning(strprintf(_(
2055                    "Disk space for %s may not accommodate the block files. " \
2056                    "Approximately %u GB of data will be stored in this directory."
2057                ),
2058                fs::quoted(fs::PathToString(args.GetBlocksDirPath())),
2059                chainparams.AssumedBlockchainSize()
2060            ));
2061        }
2062    }
2063
2064#ifdef __APPLE__
2065    auto check_and_warn_fs{[&](const fs::path& path, std::string_view desc) {
2066        const auto path_desc{strprintf("%s (\"%s\")", desc, fs::PathToString(path))};
2067        switch (GetFilesystemType(path)) {
2068        case FSType::EXFAT:
2069            InitWarning(strprintf(_("The %s path uses exFAT, which is known to have intermittent corruption problems on macOS. "
2070                "Move this directory to a different filesystem to avoid data loss."), path_desc));
2071            break;
2072        case FSType::ERROR:
2073            LogInfo("Failed to detect filesystem type for %s", path_desc);
2074            break;
2075        case FSType::OTHER:
2076            break;
2077        }
2078    }};
2079
2080    check_and_warn_fs(args.GetDataDirNet(), "data directory");
2081    check_and_warn_fs(args.GetBlocksDirPath(), "blocks directory");
2082#endif
2083
2084#if HAVE_SYSTEM
2085    const std::string block_notify = args.GetArg("-blocknotify", "");
2086    if (!block_notify.empty()) {
2087        uiInterface.NotifyBlockTip.connect([block_notify](SynchronizationState sync_state, const CBlockIndex& block, double /* verification_progress */) {
2088            if (sync_state != SynchronizationState::POST_INIT) return;
2089            std::string command = block_notify;
2090            ReplaceAll(command, "%s", block.GetBlockHash().GetHex());
2091            std::thread t(runCommand, command);
2092            t.detach(); // thread runs free
2093        });
2094    }
2095#endif
2096
2097    std::vector<fs::path> vImportFiles;
2098    for (const std::string& strFile : args.GetArgs("-loadblock")) {
2099        vImportFiles.push_back(fs::PathFromString(strFile));
2100    }
2101
2102    /// \anchor initload
2103    node.background_init_thread = std::thread(&util::TraceThread, "initload", [=, &chainman, &args, &kernel_notifications, &node] {
2104        ScheduleBatchPriority();
2105        // Import blocks and ActivateBestChain()
2106        ImportBlocks(chainman, vImportFiles);
2107        // An interrupted import may return without activating genesis. Wake
2108        // the init thread's genesis wait, which is otherwise only notified
2109        // on blockTip, and that never fires when the import was interrupted
2110        // before activating genesis. This wakeup lets the wait observe the
2111        // shutdown request.
2112        WITH_LOCK(kernel_notifications.m_tip_block_mutex, kernel_notifications.m_tip_block_cv.notify_all());
2113        WITH_LOCK(::cs_main, chainman.UpdateIBDStatus());
2114        if (args.GetBoolArg("-stopafterblockimport", DEFAULT_STOPAFTERBLOCKIMPORT)) {
2115            LogInfo("Stopping after block import");
2116            if (!(Assert(node.shutdown_request))()) {
2117                LogError("Failed to send shutdown signal after finishing block import\n");
2118            }
2119            return;
2120        }
2121
2122        // Start indexes initial sync
2123        if (!StartIndexBackgroundSync(node)) {
2124            bilingual_str err_str = _("Failed to start indexes, shutting down…");
2125            chainman.GetNotifications().fatalError(err_str);
2126            return;
2127        }
2128        // Load mempool from disk
2129        if (auto* pool{chainman.ActiveChainstate().GetMempool()}) {
2130            const bool loaded{LoadMempool(*pool, ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{}, chainman.ActiveChainstate(), {})};
2131            // A shutdown request sets m_interrupt and aborts the mempool load, which is not a
2132            // load failure, so only notify the fee estimator when the load actually failed.
2133            if (node.fee_estimator_man && !chainman.m_interrupt && !loaded) {
2134                node.fee_estimator_man->MempoolLoadFailed();
2135            }
2136            pool->SetLoadTried(!chainman.m_interrupt);
2137        }
2138    });
2139
2140    /*
2141     * Wait for genesis block to be processed. Typically kernel_notifications.m_tip_block
2142     * has already been set by a call to LoadChainTip() in CompleteChainstateInitialization().
2143     * But this is skipped if the chainstate doesn't exist yet or is being wiped:
2144     *
2145     * 1. first startup with an empty datadir
2146     * 2. reindex
2147     * 3. reindex-chainstate
2148     *
2149     * In these case it's connected by a call to ActivateBestChain() in the initload thread.
2150     */
2151    {
2152        WAIT_LOCK(kernel_notifications.m_tip_block_mutex, lock);
2153        kernel_notifications.m_tip_block_cv.wait(lock, [&]() EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
2154            return kernel_notifications.TipBlock() || ShutdownRequested(node);
2155        });
2156    }
2157
2158    if (ShutdownRequested(node)) {
2159        return true;
2160    }
2161
2162    // ********************************************************* Step 12: start node
2163
2164    int64_t best_block_time{};
2165    {
2166        LOCK(chainman.GetMutex());
2167        const auto& tip{*Assert(chainman.ActiveTip())};
2168        LogInfo("block tree size = %u", chainman.BlockIndex().size());
2169        chain_active_height = tip.nHeight;
2170        best_block_time = tip.GetBlockTime();
2171        if (tip_info) {
2172            tip_info->block_height = chain_active_height;
2173            tip_info->block_time = best_block_time;
2174            tip_info->verification_progress = chainman.GuessVerificationProgress(&tip);
2175        }
2176        if (tip_info && chainman.m_best_header) {
2177            tip_info->header_height = chainman.m_best_header->nHeight;
2178            tip_info->header_time = chainman.m_best_header->GetBlockTime();
2179        }
2180    }
2181    LogInfo("nBestHeight = %d", chain_active_height);
2182    if (node.peerman) node.peerman->SetBestBlock(chain_active_height, std::chrono::seconds{best_block_time});
2183
2184    // Map ports with NAT-PMP
2185    StartMapPort(args.GetBoolArg("-natpmp", DEFAULT_NATPMP));
2186
2187    CConnman::Options connOptions;
2188    connOptions.m_local_services = g_local_services;
2189    connOptions.m_max_automatic_connections = num_p2p_max_connections;
2190    connOptions.m_full_relay_inbound_percent = std::clamp<int>(args.GetIntArg("-inboundrelaypercent", DEFAULT_FULL_RELAY_INBOUND_PCT), 0, 100);
2191    connOptions.uiInterface = &uiInterface;
2192    connOptions.m_banman = node.banman.get();
2193    connOptions.m_msgproc = node.peerman.get();
2194    connOptions.nSendBufferMaxSize = 1000 * args.GetIntArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
2195    connOptions.nReceiveFloodSize = 1000 * args.GetIntArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
2196    for (const std::string& added_node : args.GetArgs("-addnode")) {
2197        // Such a value is not a valid connection target, but would otherwise be
2198        // treated as one and retried indefinitely.
2199        if (TrimStringView(added_node).empty()) {
2200            LogWarning("Ignoring empty -addnode value");
2201            continue;
2202        }
2203        connOptions.m_added_nodes.push_back(added_node);
2204    }
2205    connOptions.nMaxOutboundLimit = *opt_max_upload;
2206    connOptions.m_peer_connect_timeout = peer_connect_timeout;
2207    connOptions.whitelist_forcerelay = args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY);
2208    connOptions.whitelist_relay = args.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY);
2209    connOptions.m_capture_messages = args.GetBoolArg("-capturemessages", false);
2210
2211    // Port to bind to if `-bind=addr` is provided without a `:port` suffix.
2212    const uint16_t default_bind_port =
2213        static_cast<uint16_t>(args.GetIntArg("-port", Params().GetDefaultPort()));
2214
2215    const uint16_t default_bind_port_onion = default_bind_port + 1;
2216
2217    const auto BadPortWarning = [](const char* prefix, uint16_t port) {
2218        return strprintf(_("%s request to listen on port %u. This port is considered \"bad\" and "
2219                           "thus it is unlikely that any peer will connect to it. See "
2220                           "doc/p2p-bad-ports.md for details and a full list."),
2221                         prefix,
2222                         port);
2223    };
2224
2225    for (const std::string& bind_arg : args.GetArgs("-bind")) {
2226        std::optional<CService> bind_addr;
2227        const size_t index = bind_arg.rfind('=');
2228        if (index == std::string::npos) {
2229            bind_addr = Lookup(bind_arg, default_bind_port, /*fAllowLookup=*/false);
2230            if (bind_addr.has_value()) {
2231                connOptions.vBinds.push_back(bind_addr.value());
2232                if (IsBadPort(bind_addr.value().GetPort())) {
2233                    InitWarning(BadPortWarning("-bind", bind_addr.value().GetPort()));
2234                }
2235                continue;
2236            }
2237        } else {
2238            const std::string network_type = bind_arg.substr(index + 1);
2239            if (network_type == "onion") {
2240                const std::string truncated_bind_arg = bind_arg.substr(0, index);
2241                bind_addr = Lookup(truncated_bind_arg, default_bind_port_onion, false);
2242                if (bind_addr.has_value()) {
2243                    connOptions.onion_binds.push_back(bind_addr.value());
2244                    continue;
2245                }
2246            }
2247        }
2248        return InitError(ResolveErrMsg("bind", bind_arg));
2249    }
2250