node.cpp
1 // Copyright (c) 2010 Satoshi Nakamoto 2 // Copyright (c) 2009-2022 The Bitcoin Core developers 3 // Distributed under the MIT software license, see the accompanying 4 // file COPYING or http://www.opensource.org/licenses/mit-license.php. 5 6 #include <bitcoin-build-config.h> // IWYU pragma: keep 7 8 #include <chainparams.h> 9 #include <httpserver.h> 10 #include <index/blockfilterindex.h> 11 #include <index/coinstatsindex.h> 12 #include <index/txindex.h> 13 #include <interfaces/chain.h> 14 #include <interfaces/echo.h> 15 #include <interfaces/init.h> 16 #include <interfaces/ipc.h> 17 #include <kernel/cs_main.h> 18 #include <logging.h> 19 #include <node/context.h> 20 #include <rpc/server.h> 21 #include <rpc/server_util.h> 22 #include <rpc/util.h> 23 #include <scheduler.h> 24 #include <univalue.h> 25 #include <util/any.h> 26 #include <util/check.h> 27 #include <util/time.h> 28 29 #include <stdint.h> 30 #ifdef HAVE_MALLOC_INFO 31 #include <malloc.h> 32 #endif 33 34 using node::NodeContext; 35 36 static RPCHelpMan setmocktime() 37 { 38 return RPCHelpMan{"setmocktime", 39 "\nSet the local time to given timestamp (-regtest only)\n", 40 { 41 {"timestamp", RPCArg::Type::NUM, RPCArg::Optional::NO, UNIX_EPOCH_TIME + "\n" 42 "Pass 0 to go back to using the system time."}, 43 }, 44 RPCResult{RPCResult::Type::NONE, "", ""}, 45 RPCExamples{""}, 46 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 47 { 48 if (!Params().IsMockableChain()) { 49 throw std::runtime_error("setmocktime is for regression testing (-regtest mode) only"); 50 } 51 52 // For now, don't change mocktime if we're in the middle of validation, as 53 // this could have an effect on mempool time-based eviction, as well as 54 // IsCurrentForFeeEstimation() and IsInitialBlockDownload(). 55 // TODO: figure out the right way to synchronize around mocktime, and 56 // ensure all call sites of GetTime() are accessing this safely. 57 LOCK(cs_main); 58 59 const int64_t time{request.params[0].getInt<int64_t>()}; 60 constexpr int64_t max_time{Ticks<std::chrono::seconds>(std::chrono::nanoseconds::max())}; 61 if (time < 0 || time > max_time) { 62 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Mocktime must be in the range [0, %s], not %s.", max_time, time)); 63 } 64 65 SetMockTime(time); 66 const NodeContext& node_context{EnsureAnyNodeContext(request.context)}; 67 for (const auto& chain_client : node_context.chain_clients) { 68 chain_client->setMockTime(time); 69 } 70 71 return UniValue::VNULL; 72 }, 73 }; 74 } 75 76 static RPCHelpMan mockscheduler() 77 { 78 return RPCHelpMan{"mockscheduler", 79 "\nBump the scheduler into the future (-regtest only)\n", 80 { 81 {"delta_time", RPCArg::Type::NUM, RPCArg::Optional::NO, "Number of seconds to forward the scheduler into the future." }, 82 }, 83 RPCResult{RPCResult::Type::NONE, "", ""}, 84 RPCExamples{""}, 85 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 86 { 87 if (!Params().IsMockableChain()) { 88 throw std::runtime_error("mockscheduler is for regression testing (-regtest mode) only"); 89 } 90 91 int64_t delta_seconds = request.params[0].getInt<int64_t>(); 92 if (delta_seconds <= 0 || delta_seconds > 3600) { 93 throw std::runtime_error("delta_time must be between 1 and 3600 seconds (1 hr)"); 94 } 95 96 const NodeContext& node_context{EnsureAnyNodeContext(request.context)}; 97 CHECK_NONFATAL(node_context.scheduler)->MockForward(std::chrono::seconds{delta_seconds}); 98 CHECK_NONFATAL(node_context.validation_signals)->SyncWithValidationInterfaceQueue(); 99 for (const auto& chain_client : node_context.chain_clients) { 100 chain_client->schedulerMockForward(std::chrono::seconds(delta_seconds)); 101 } 102 103 return UniValue::VNULL; 104 }, 105 }; 106 } 107 108 static UniValue RPCLockedMemoryInfo() 109 { 110 LockedPool::Stats stats = LockedPoolManager::Instance().stats(); 111 UniValue obj(UniValue::VOBJ); 112 obj.pushKV("used", uint64_t(stats.used)); 113 obj.pushKV("free", uint64_t(stats.free)); 114 obj.pushKV("total", uint64_t(stats.total)); 115 obj.pushKV("locked", uint64_t(stats.locked)); 116 obj.pushKV("chunks_used", uint64_t(stats.chunks_used)); 117 obj.pushKV("chunks_free", uint64_t(stats.chunks_free)); 118 return obj; 119 } 120 121 #ifdef HAVE_MALLOC_INFO 122 static std::string RPCMallocInfo() 123 { 124 char *ptr = nullptr; 125 size_t size = 0; 126 FILE *f = open_memstream(&ptr, &size); 127 if (f) { 128 malloc_info(0, f); 129 fclose(f); 130 if (ptr) { 131 std::string rv(ptr, size); 132 free(ptr); 133 return rv; 134 } 135 } 136 return ""; 137 } 138 #endif 139 140 static RPCHelpMan getmemoryinfo() 141 { 142 /* Please, avoid using the word "pool" here in the RPC interface or help, 143 * as users will undoubtedly confuse it with the other "memory pool" 144 */ 145 return RPCHelpMan{"getmemoryinfo", 146 "Returns an object containing information about memory usage.\n", 147 { 148 {"mode", RPCArg::Type::STR, RPCArg::Default{"stats"}, "determines what kind of information is returned.\n" 149 " - \"stats\" returns general statistics about memory usage in the daemon.\n" 150 " - \"mallocinfo\" returns an XML string describing low-level heap state (only available if compiled with glibc)."}, 151 }, 152 { 153 RPCResult{"mode \"stats\"", 154 RPCResult::Type::OBJ, "", "", 155 { 156 {RPCResult::Type::OBJ, "locked", "Information about locked memory manager", 157 { 158 {RPCResult::Type::NUM, "used", "Number of bytes used"}, 159 {RPCResult::Type::NUM, "free", "Number of bytes available in current arenas"}, 160 {RPCResult::Type::NUM, "total", "Total number of bytes managed"}, 161 {RPCResult::Type::NUM, "locked", "Amount of bytes that succeeded locking. If this number is smaller than total, locking pages failed at some point and key data could be swapped to disk."}, 162 {RPCResult::Type::NUM, "chunks_used", "Number allocated chunks"}, 163 {RPCResult::Type::NUM, "chunks_free", "Number unused chunks"}, 164 }}, 165 } 166 }, 167 RPCResult{"mode \"mallocinfo\"", 168 RPCResult::Type::STR, "", "\"<malloc version=\"1\">...\"" 169 }, 170 }, 171 RPCExamples{ 172 HelpExampleCli("getmemoryinfo", "") 173 + HelpExampleRpc("getmemoryinfo", "") 174 }, 175 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 176 { 177 std::string mode = request.params[0].isNull() ? "stats" : request.params[0].get_str(); 178 if (mode == "stats") { 179 UniValue obj(UniValue::VOBJ); 180 obj.pushKV("locked", RPCLockedMemoryInfo()); 181 return obj; 182 } else if (mode == "mallocinfo") { 183 #ifdef HAVE_MALLOC_INFO 184 return RPCMallocInfo(); 185 #else 186 throw JSONRPCError(RPC_INVALID_PARAMETER, "mallocinfo mode not available"); 187 #endif 188 } else { 189 throw JSONRPCError(RPC_INVALID_PARAMETER, "unknown mode " + mode); 190 } 191 }, 192 }; 193 } 194 195 static void EnableOrDisableLogCategories(UniValue cats, bool enable) { 196 cats = cats.get_array(); 197 for (unsigned int i = 0; i < cats.size(); ++i) { 198 std::string cat = cats[i].get_str(); 199 200 bool success; 201 if (enable) { 202 success = LogInstance().EnableCategory(cat); 203 } else { 204 success = LogInstance().DisableCategory(cat); 205 } 206 207 if (!success) { 208 throw JSONRPCError(RPC_INVALID_PARAMETER, "unknown logging category " + cat); 209 } 210 } 211 } 212 213 static RPCHelpMan logging() 214 { 215 return RPCHelpMan{"logging", 216 "Gets and sets the logging configuration.\n" 217 "When called without an argument, returns the list of categories with status that are currently being debug logged or not.\n" 218 "When called with arguments, adds or removes categories from debug logging and return the lists above.\n" 219 "The arguments are evaluated in order \"include\", \"exclude\".\n" 220 "If an item is both included and excluded, it will thus end up being excluded.\n" 221 "The valid logging categories are: " + LogInstance().LogCategoriesString() + "\n" 222 "In addition, the following are available as category names with special meanings:\n" 223 " - \"all\", \"1\" : represent all logging categories.\n" 224 , 225 { 226 {"include", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "The categories to add to debug logging", 227 { 228 {"include_category", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "the valid logging category"}, 229 }}, 230 {"exclude", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "The categories to remove from debug logging", 231 { 232 {"exclude_category", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "the valid logging category"}, 233 }}, 234 }, 235 RPCResult{ 236 RPCResult::Type::OBJ_DYN, "", "keys are the logging categories, and values indicates its status", 237 { 238 {RPCResult::Type::BOOL, "category", "if being debug logged or not. false:inactive, true:active"}, 239 } 240 }, 241 RPCExamples{ 242 HelpExampleCli("logging", "\"[\\\"all\\\"]\" \"[\\\"http\\\"]\"") 243 + HelpExampleRpc("logging", "[\"all\"], [\"libevent\"]") 244 }, 245 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 246 { 247 BCLog::CategoryMask original_log_categories = LogInstance().GetCategoryMask(); 248 if (request.params[0].isArray()) { 249 EnableOrDisableLogCategories(request.params[0], true); 250 } 251 if (request.params[1].isArray()) { 252 EnableOrDisableLogCategories(request.params[1], false); 253 } 254 BCLog::CategoryMask updated_log_categories = LogInstance().GetCategoryMask(); 255 BCLog::CategoryMask changed_log_categories = original_log_categories ^ updated_log_categories; 256 257 // Update libevent logging if BCLog::LIBEVENT has changed. 258 if (changed_log_categories & BCLog::LIBEVENT) { 259 UpdateHTTPServerLogging(LogInstance().WillLogCategory(BCLog::LIBEVENT)); 260 } 261 262 UniValue result(UniValue::VOBJ); 263 for (const auto& logCatActive : LogInstance().LogCategoriesList()) { 264 result.pushKV(logCatActive.category, logCatActive.active); 265 } 266 267 return result; 268 }, 269 }; 270 } 271 272 static RPCHelpMan echo(const std::string& name) 273 { 274 return RPCHelpMan{name, 275 "\nSimply echo back the input arguments. This command is for testing.\n" 276 "\nIt will return an internal bug report when arg9='trigger_internal_bug' is passed.\n" 277 "\nThe difference between echo and echojson is that echojson has argument conversion enabled in the client-side table in " 278 "bitcoin-cli and the GUI. There is no server-side difference.", 279 { 280 {"arg0", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}}, 281 {"arg1", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}}, 282 {"arg2", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}}, 283 {"arg3", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}}, 284 {"arg4", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}}, 285 {"arg5", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}}, 286 {"arg6", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}}, 287 {"arg7", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}}, 288 {"arg8", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}}, 289 {"arg9", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}}, 290 }, 291 RPCResult{RPCResult::Type::ANY, "", "Returns whatever was passed in"}, 292 RPCExamples{""}, 293 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 294 { 295 if (request.params[9].isStr()) { 296 CHECK_NONFATAL(request.params[9].get_str() != "trigger_internal_bug"); 297 } 298 299 return request.params; 300 }, 301 }; 302 } 303 304 static RPCHelpMan echo() { return echo("echo"); } 305 static RPCHelpMan echojson() { return echo("echojson"); } 306 307 static RPCHelpMan echoipc() 308 { 309 return RPCHelpMan{ 310 "echoipc", 311 "\nEcho back the input argument, passing it through a spawned process in a multiprocess build.\n" 312 "This command is for testing.\n", 313 {{"arg", RPCArg::Type::STR, RPCArg::Optional::NO, "The string to echo",}}, 314 RPCResult{RPCResult::Type::STR, "echo", "The echoed string."}, 315 RPCExamples{HelpExampleCli("echo", "\"Hello world\"") + 316 HelpExampleRpc("echo", "\"Hello world\"")}, 317 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue { 318 interfaces::Init& local_init = *EnsureAnyNodeContext(request.context).init; 319 std::unique_ptr<interfaces::Echo> echo; 320 if (interfaces::Ipc* ipc = local_init.ipc()) { 321 // Spawn a new bitcoin-node process and call makeEcho to get a 322 // client pointer to a interfaces::Echo instance running in 323 // that process. This is just for testing. A slightly more 324 // realistic test spawning a different executable instead of 325 // the same executable would add a new bitcoin-echo executable, 326 // and spawn bitcoin-echo below instead of bitcoin-node. But 327 // using bitcoin-node avoids the need to build and install a 328 // new executable just for this one test. 329 auto init = ipc->spawnProcess("bitcoin-node"); 330 echo = init->makeEcho(); 331 ipc->addCleanup(*echo, [init = init.release()] { delete init; }); 332 } else { 333 // IPC support is not available because this is a bitcoind 334 // process not a bitcoind-node process, so just create a local 335 // interfaces::Echo object and return it so the `echoipc` RPC 336 // method will work, and the python test calling `echoipc` 337 // can expect the same result. 338 echo = local_init.makeEcho(); 339 } 340 return echo->echo(request.params[0].get_str()); 341 }, 342 }; 343 } 344 345 static UniValue SummaryToJSON(const IndexSummary&& summary, std::string index_name) 346 { 347 UniValue ret_summary(UniValue::VOBJ); 348 if (!index_name.empty() && index_name != summary.name) return ret_summary; 349 350 UniValue entry(UniValue::VOBJ); 351 entry.pushKV("synced", summary.synced); 352 entry.pushKV("best_block_height", summary.best_block_height); 353 ret_summary.pushKV(summary.name, std::move(entry)); 354 return ret_summary; 355 } 356 357 static RPCHelpMan getindexinfo() 358 { 359 return RPCHelpMan{"getindexinfo", 360 "\nReturns the status of one or all available indices currently running in the node.\n", 361 { 362 {"index_name", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Filter results for an index with a specific name."}, 363 }, 364 RPCResult{ 365 RPCResult::Type::OBJ_DYN, "", "", { 366 { 367 RPCResult::Type::OBJ, "name", "The name of the index", 368 { 369 {RPCResult::Type::BOOL, "synced", "Whether the index is synced or not"}, 370 {RPCResult::Type::NUM, "best_block_height", "The block height to which the index is synced"}, 371 } 372 }, 373 }, 374 }, 375 RPCExamples{ 376 HelpExampleCli("getindexinfo", "") 377 + HelpExampleRpc("getindexinfo", "") 378 + HelpExampleCli("getindexinfo", "txindex") 379 + HelpExampleRpc("getindexinfo", "txindex") 380 }, 381 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 382 { 383 UniValue result(UniValue::VOBJ); 384 const std::string index_name = request.params[0].isNull() ? "" : request.params[0].get_str(); 385 386 if (g_txindex) { 387 result.pushKVs(SummaryToJSON(g_txindex->GetSummary(), index_name)); 388 } 389 390 if (g_coin_stats_index) { 391 result.pushKVs(SummaryToJSON(g_coin_stats_index->GetSummary(), index_name)); 392 } 393 394 ForEachBlockFilterIndex([&result, &index_name](const BlockFilterIndex& index) { 395 result.pushKVs(SummaryToJSON(index.GetSummary(), index_name)); 396 }); 397 398 return result; 399 }, 400 }; 401 } 402 403 void RegisterNodeRPCCommands(CRPCTable& t) 404 { 405 static const CRPCCommand commands[]{ 406 {"control", &getmemoryinfo}, 407 {"control", &logging}, 408 {"util", &getindexinfo}, 409 {"hidden", &setmocktime}, 410 {"hidden", &mockscheduler}, 411 {"hidden", &echo}, 412 {"hidden", &echojson}, 413 {"hidden", &echoipc}, 414 }; 415 for (const auto& c : commands) { 416 t.appendCommand(c.name, &c); 417 } 418 }