diff --git a/src/logging.cpp b/src/logging.cpp index 560f216d9..e0ef0aea0 100644 --- a/src/logging.cpp +++ b/src/logging.cpp @@ -1,216 +1,215 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2016 The Bitcoin Core developers // Copyright (c) 2017-2018 The Bitcoin developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #include "logging.h" #include "util.h" -#include "utilstrencodings.h" #include "utiltime.h" bool fLogIPs = DEFAULT_LOGIPS; /** * NOTE: the logger instance is leaked on exit. This is ugly, but will be * cleaned up by the OS/libc. Defining a logger as a global object doesn't work * since the order of destruction of static/global objects is undefined. * Consider if the logger gets destroyed, and then some later destructor calls * LogPrintf, maybe indirectly, and you get a core dump at shutdown trying to * access the logger. When the shutdown sequence is fully audited and tested, * explicit destruction of these objects can be implemented by changing this * from a raw pointer to a std::unique_ptr. * * This method of initialization was originally introduced in * ee3374234c60aba2cc4c5cd5cac1c0aefc2d817c. */ BCLog::Logger &GetLogger() { static BCLog::Logger *const logger = new BCLog::Logger(); return *logger; } static int FileWriteStr(const std::string &str, FILE *fp) { return fwrite(str.data(), 1, str.size(), fp); } void BCLog::Logger::OpenDebugLog() { - boost::mutex::scoped_lock scoped_lock(mutexDebugLog); + std::lock_guard scoped_lock(mutexDebugLog); assert(fileout == nullptr); fs::path pathDebug = GetDataDir() / "debug.log"; fileout = fsbridge::fopen(pathDebug, "a"); if (fileout) { // Unbuffered. setbuf(fileout, nullptr); // Dump buffered messages from before we opened the log. while (!vMsgsBeforeOpenLog.empty()) { FileWriteStr(vMsgsBeforeOpenLog.front(), fileout); vMsgsBeforeOpenLog.pop_front(); } } } struct CLogCategoryDesc { BCLog::LogFlags flag; std::string category; }; const CLogCategoryDesc LogCategories[] = { {BCLog::NONE, "0"}, {BCLog::NET, "net"}, {BCLog::TOR, "tor"}, {BCLog::MEMPOOL, "mempool"}, {BCLog::HTTP, "http"}, {BCLog::BENCH, "bench"}, {BCLog::ZMQ, "zmq"}, {BCLog::DB, "db"}, {BCLog::RPC, "rpc"}, {BCLog::ESTIMATEFEE, "estimatefee"}, {BCLog::ADDRMAN, "addrman"}, {BCLog::SELECTCOINS, "selectcoins"}, {BCLog::REINDEX, "reindex"}, {BCLog::CMPCTBLOCK, "cmpctblock"}, {BCLog::RAND, "rand"}, {BCLog::PRUNE, "prune"}, {BCLog::PROXY, "proxy"}, {BCLog::MEMPOOLREJ, "mempoolrej"}, {BCLog::LIBEVENT, "libevent"}, {BCLog::COINDB, "coindb"}, {BCLog::QT, "qt"}, {BCLog::LEVELDB, "leveldb"}, {BCLog::ALL, "1"}, {BCLog::ALL, "all"}, }; bool GetLogCategory(BCLog::LogFlags &flag, const std::string &str) { if (str == "") { flag = BCLog::ALL; return true; } - for (unsigned int i = 0; i < ARRAYLEN(LogCategories); i++) { - if (LogCategories[i].category == str) { - flag = LogCategories[i].flag; + for (const CLogCategoryDesc &category_desc : LogCategories) { + if (category_desc.category == str) { + flag = category_desc.flag; return true; } } return false; } std::string ListLogCategories() { std::string ret; int outcount = 0; - for (unsigned int i = 0; i < ARRAYLEN(LogCategories); i++) { + for (const CLogCategoryDesc &category_desc : LogCategories) { // Omit the special cases. - if (LogCategories[i].flag != BCLog::NONE && - LogCategories[i].flag != BCLog::ALL) { + if (category_desc.flag != BCLog::NONE && + category_desc.flag != BCLog::ALL) { if (outcount != 0) ret += ", "; - ret += LogCategories[i].category; + ret += category_desc.category; outcount++; } } return ret; } BCLog::Logger::~Logger() { if (fileout) { fclose(fileout); } } std::string BCLog::Logger::LogTimestampStr(const std::string &str) { std::string strStamped; if (!fLogTimestamps) return str; if (fStartedNewLine) { int64_t nTimeMicros = GetLogTimeMicros(); strStamped = DateTimeStrFormat("%Y-%m-%d %H:%M:%S", nTimeMicros / 1000000); if (fLogTimeMicros) strStamped += strprintf(".%06d", nTimeMicros % 1000000); strStamped += ' ' + str; } else strStamped = str; if (!str.empty() && str[str.size() - 1] == '\n') fStartedNewLine = true; else fStartedNewLine = false; return strStamped; } int BCLog::Logger::LogPrintStr(const std::string &str) { // Returns total number of characters written. int ret = 0; std::string strTimestamped = LogTimestampStr(str); if (fPrintToConsole) { // Print to console. ret = fwrite(strTimestamped.data(), 1, strTimestamped.size(), stdout); fflush(stdout); } else if (fPrintToDebugLog) { - boost::mutex::scoped_lock scoped_lock(mutexDebugLog); + std::lock_guard scoped_lock(mutexDebugLog); // Buffer if we haven't opened the log yet. if (fileout == nullptr) { ret = strTimestamped.length(); vMsgsBeforeOpenLog.push_back(strTimestamped); } else { // Reopen the log file, if requested. if (fReopenDebugLog) { fReopenDebugLog = false; fs::path pathDebug = GetDataDir() / "debug.log"; if (fsbridge::freopen(pathDebug, "a", fileout) != nullptr) { // unbuffered. setbuf(fileout, nullptr); } } ret = FileWriteStr(strTimestamped, fileout); } } return ret; } void BCLog::Logger::ShrinkDebugFile() { // Amount of debug.log to save at end when shrinking (must fit in memory) constexpr size_t RECENT_DEBUG_HISTORY_SIZE = 10 * 1000000; // Scroll debug.log if it's getting too big. fs::path pathLog = GetDataDir() / "debug.log"; FILE *file = fsbridge::fopen(pathLog, "r"); // If debug.log file is more than 10% bigger the RECENT_DEBUG_HISTORY_SIZE // trim it down by saving only the last RECENT_DEBUG_HISTORY_SIZE bytes. if (file && fs::file_size(pathLog) > 11 * (RECENT_DEBUG_HISTORY_SIZE / 10)) { // Restart the file with some of the end. std::vector vch(RECENT_DEBUG_HISTORY_SIZE, 0); fseek(file, -((long)vch.size()), SEEK_END); int nBytes = fread(vch.data(), 1, vch.size(), file); fclose(file); file = fsbridge::fopen(pathLog, "w"); if (file) { fwrite(vch.data(), 1, nBytes, file); fclose(file); } } else if (file != nullptr) fclose(file); } void BCLog::Logger::EnableCategory(LogFlags category) { logCategories |= category; } void BCLog::Logger::DisableCategory(LogFlags category) { logCategories &= ~category; } bool BCLog::Logger::WillLogCategory(LogFlags category) const { return (logCategories.load(std::memory_order_relaxed) & category) != 0; } bool BCLog::Logger::DefaultShrinkDebugFile() const { return logCategories != BCLog::NONE; } diff --git a/src/logging.h b/src/logging.h index b0a242df9..672da5be6 100644 --- a/src/logging.h +++ b/src/logging.h @@ -1,125 +1,124 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2016 The Bitcoin Core developers // Copyright (c) 2017-2018 The Bitcoin developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #ifndef BITCOIN_LOGGING_H #define BITCOIN_LOGGING_H #include #include #include +#include #include -#include - static const bool DEFAULT_LOGTIMEMICROS = false; static const bool DEFAULT_LOGIPS = false; static const bool DEFAULT_LOGTIMESTAMPS = true; extern bool fLogIPs; namespace BCLog { enum LogFlags : uint32_t { NONE = 0, NET = (1 << 0), TOR = (1 << 1), MEMPOOL = (1 << 2), HTTP = (1 << 3), BENCH = (1 << 4), ZMQ = (1 << 5), DB = (1 << 6), RPC = (1 << 7), ESTIMATEFEE = (1 << 8), ADDRMAN = (1 << 9), SELECTCOINS = (1 << 10), REINDEX = (1 << 11), CMPCTBLOCK = (1 << 12), RAND = (1 << 13), PRUNE = (1 << 14), PROXY = (1 << 15), MEMPOOLREJ = (1 << 16), LIBEVENT = (1 << 17), COINDB = (1 << 18), QT = (1 << 19), LEVELDB = (1 << 20), ALL = ~uint32_t(0), }; class Logger { private: FILE *fileout = nullptr; - boost::mutex mutexDebugLog; + std::mutex mutexDebugLog; std::list vMsgsBeforeOpenLog; /** * fStartedNewLine is a state variable that will suppress printing of the * timestamp when multiple calls are made that don't end in a newline. */ std::atomic_bool fStartedNewLine{true}; /** * Log categories bitfield. Leveldb/libevent need special handling if their * flags are changed at runtime. */ std::atomic logCategories{0}; std::string LogTimestampStr(const std::string &str); public: bool fPrintToConsole = false; bool fPrintToDebugLog = true; bool fLogTimestamps = DEFAULT_LOGTIMESTAMPS; bool fLogTimeMicros = DEFAULT_LOGTIMEMICROS; std::atomic fReopenDebugLog{false}; ~Logger(); /** Send a string to the log output */ int LogPrintStr(const std::string &str); void OpenDebugLog(); void ShrinkDebugFile(); void EnableCategory(LogFlags category); void DisableCategory(LogFlags category); /** Return true if log accepts specified category */ bool WillLogCategory(LogFlags category) const; /** Default for whether ShrinkDebugFile should be run */ bool DefaultShrinkDebugFile() const; }; } // namespace BCLog BCLog::Logger &GetLogger(); /** Return true if log accepts specified category */ static inline bool LogAcceptCategory(BCLog::LogFlags category) { return GetLogger().WillLogCategory(category); } /** Returns a string with the supported log categories */ std::string ListLogCategories(); /** Return true if str parses as a log category and set the flag */ bool GetLogCategory(BCLog::LogFlags &flag, const std::string &str); #define LogPrint(category, ...) \ do { \ if (LogAcceptCategory((category))) { \ GetLogger().LogPrintStr(tfm::format(__VA_ARGS__)); \ } \ } while (0) #define LogPrintf(...) \ do { \ GetLogger().LogPrintStr(tfm::format(__VA_ARGS__)); \ } while (0) #endif // BITCOIN_LOGGING_H