From 0e0a007a2503d468391004c8ea2faae305232345 Mon Sep 17 00:00:00 2001 From: Yuri Kunde Schlesner Date: Sat, 6 Dec 2014 20:00:08 -0200 Subject: [PATCH] Add configurable per-class log filtering --- src/citra/citra.cpp | 5 +- src/citra/config.cpp | 2 +- src/citra/default_ini.h | 2 +- src/citra_qt/config.cpp | 4 +- src/citra_qt/main.cpp | 12 ++- src/common/CMakeLists.txt | 2 + src/common/logging/filter.cpp | 132 ++++++++++++++++++++++++++ src/common/logging/filter.h | 63 ++++++++++++ src/common/logging/text_formatter.cpp | 8 +- src/common/logging/text_formatter.h | 3 +- src/core/settings.h | 4 +- 11 files changed, 223 insertions(+), 14 deletions(-) create mode 100644 src/common/logging/filter.cpp create mode 100644 src/common/logging/filter.h diff --git a/src/citra/citra.cpp b/src/citra/citra.cpp index d192428e90..d6e8a4ec79 100644 --- a/src/citra/citra.cpp +++ b/src/citra/citra.cpp @@ -7,6 +7,7 @@ #include "common/common.h" #include "common/logging/text_formatter.h" #include "common/logging/backend.h" +#include "common/logging/filter.h" #include "common/scope_exit.h" #include "core/settings.h" @@ -20,7 +21,8 @@ /// Application entry point int __cdecl main(int argc, char **argv) { std::shared_ptr logger = Log::InitGlobalLogger(); - std::thread logging_thread(Log::TextLoggingLoop, logger); + Log::Filter log_filter(Log::Level::Debug); + std::thread logging_thread(Log::TextLoggingLoop, logger, &log_filter); SCOPE_EXIT({ logger->Close(); logging_thread.join(); @@ -32,6 +34,7 @@ int __cdecl main(int argc, char **argv) { } Config config; + log_filter.ParseFilterString(Settings::values.log_filter); std::string boot_filename = argv[1]; EmuWindow_GLFW* emu_window = new EmuWindow_GLFW; diff --git a/src/citra/config.cpp b/src/citra/config.cpp index fe0ebe5a84..92764809ee 100644 --- a/src/citra/config.cpp +++ b/src/citra/config.cpp @@ -64,7 +64,7 @@ void Config::ReadValues() { Settings::values.use_virtual_sd = glfw_config->GetBoolean("Data Storage", "use_virtual_sd", true); // Miscellaneous - Settings::values.enable_log = glfw_config->GetBoolean("Miscellaneous", "enable_log", true); + Settings::values.log_filter = glfw_config->Get("Miscellaneous", "log_filter", "*:Info"); } void Config::Reload() { diff --git a/src/citra/default_ini.h b/src/citra/default_ini.h index f1f626eed0..7cf543e07f 100644 --- a/src/citra/default_ini.h +++ b/src/citra/default_ini.h @@ -34,7 +34,7 @@ gpu_refresh_rate = ## 60 (default) use_virtual_sd = [Miscellaneous] -enable_log = +log_filter = *:Info ## Examples: *:Debug Kernel.SVC:Trace Service.*:Critical )"; } diff --git a/src/citra_qt/config.cpp b/src/citra_qt/config.cpp index 3209e5900e..0ae6b8b2d8 100644 --- a/src/citra_qt/config.cpp +++ b/src/citra_qt/config.cpp @@ -52,7 +52,7 @@ void Config::ReadValues() { qt_config->endGroup(); qt_config->beginGroup("Miscellaneous"); - Settings::values.enable_log = qt_config->value("enable_log", true).toBool(); + Settings::values.log_filter = qt_config->value("log_filter", "*:Info").toString().toStdString(); qt_config->endGroup(); } @@ -87,7 +87,7 @@ void Config::SaveValues() { qt_config->endGroup(); qt_config->beginGroup("Miscellaneous"); - qt_config->setValue("enable_log", Settings::values.enable_log); + qt_config->setValue("log_filter", QString::fromStdString(Settings::values.log_filter)); qt_config->endGroup(); } diff --git a/src/citra_qt/main.cpp b/src/citra_qt/main.cpp index 5293263cdc..817732167f 100644 --- a/src/citra_qt/main.cpp +++ b/src/citra_qt/main.cpp @@ -11,6 +11,7 @@ #include "common/logging/text_formatter.h" #include "common/logging/log.h" #include "common/logging/backend.h" +#include "common/logging/filter.h" #include "common/platform.h" #include "common/scope_exit.h" @@ -42,14 +43,10 @@ GMainWindow::GMainWindow() { - Pica::g_debug_context = Pica::DebugContext::Construct(); Config config; - if (!Settings::values.enable_log) - LogManager::Shutdown(); - ui.setupUi(this); statusBar()->hide(); @@ -277,7 +274,8 @@ void GMainWindow::closeEvent(QCloseEvent* event) int __cdecl main(int argc, char* argv[]) { std::shared_ptr logger = Log::InitGlobalLogger(); - std::thread logging_thread(Log::TextLoggingLoop, logger); + Log::Filter log_filter(Log::Level::Info); + std::thread logging_thread(Log::TextLoggingLoop, logger, &log_filter); SCOPE_EXIT({ logger->Close(); logging_thread.join(); @@ -285,7 +283,11 @@ int __cdecl main(int argc, char* argv[]) QApplication::setAttribute(Qt::AA_X11InitThreads); QApplication app(argc, argv); + GMainWindow main_window; + // After settings have been loaded by GMainWindow, apply the filter + log_filter.ParseFilterString(Settings::values.log_filter); + main_window.show(); return app.exec(); } diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt index 7c1d3d1dca..489d2bb7fd 100644 --- a/src/common/CMakeLists.txt +++ b/src/common/CMakeLists.txt @@ -11,6 +11,7 @@ set(SRCS hash.cpp key_map.cpp log_manager.cpp + logging/filter.cpp logging/text_formatter.cpp logging/backend.cpp math_util.cpp @@ -49,6 +50,7 @@ set(HEADERS log.h log_manager.h logging/text_formatter.h + logging/filter.h logging/log.h logging/backend.h math_util.h diff --git a/src/common/logging/filter.cpp b/src/common/logging/filter.cpp new file mode 100644 index 0000000000..0cf9b05e79 --- /dev/null +++ b/src/common/logging/filter.cpp @@ -0,0 +1,132 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2+ +// Refer to the license.txt file included. + +#include + +#include "common/logging/filter.h" +#include "common/logging/backend.h" +#include "common/string_util.h" + +namespace Log { + +Filter::Filter(Level default_level) { + ResetAll(default_level); +} + +void Filter::ResetAll(Level level) { + class_levels.fill(level); +} + +void Filter::SetClassLevel(Class log_class, Level level) { + class_levels[static_cast(log_class)] = level; +} + +void Filter::SetSubclassesLevel(const ClassInfo& log_class, Level level) { + const size_t log_class_i = static_cast(log_class.log_class); + + const size_t begin = log_class_i + 1; + const size_t end = begin + log_class.num_children; + for (size_t i = begin; begin < end; ++i) { + class_levels[i] = level; + } +} + +void Filter::ParseFilterString(const std::string& filter_str) { + auto clause_begin = filter_str.cbegin(); + while (clause_begin != filter_str.cend()) { + auto clause_end = std::find(clause_begin, filter_str.cend(), ' '); + + // If clause isn't empty + if (clause_end != clause_begin) { + ParseFilterRule(clause_begin, clause_end); + } + + if (clause_end != filter_str.cend()) { + // Skip over the whitespace + ++clause_end; + } + clause_begin = clause_end; + } +} + +template +static Level GetLevelByName(const It begin, const It end) { + for (u8 i = 0; i < static_cast(Level::Count); ++i) { + const char* level_name = Logger::GetLevelName(static_cast(i)); + if (Common::ComparePartialString(begin, end, level_name)) { + return static_cast(i); + } + } + return Level::Count; +} + +template +static Class GetClassByName(const It begin, const It end) { + for (ClassType i = 0; i < static_cast(Class::Count); ++i) { + const char* level_name = Logger::GetLogClassName(static_cast(i)); + if (Common::ComparePartialString(begin, end, level_name)) { + return static_cast(i); + } + } + return Class::Count; +} + +template +static InputIt find_last(InputIt begin, const InputIt end, const T& value) { + auto match = end; + while (begin != end) { + auto new_match = std::find(begin, end, value); + if (new_match != end) { + match = new_match; + ++new_match; + } + begin = new_match; + } + return match; +} + +bool Filter::ParseFilterRule(const std::string::const_iterator begin, + const std::string::const_iterator end) { + auto level_separator = std::find(begin, end, ':'); + if (level_separator == end) { + LOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: %s", + std::string(begin, end).c_str()); + return false; + } + + const Level level = GetLevelByName(level_separator + 1, end); + if (level == Level::Count) { + LOG_ERROR(Log, "Unknown log level in filter: %s", std::string(begin, end).c_str()); + return false; + } + + if (Common::ComparePartialString(begin, level_separator, "*")) { + ResetAll(level); + return true; + } + + auto class_name_end = find_last(begin, level_separator, '.'); + if (class_name_end != level_separator && + !Common::ComparePartialString(class_name_end + 1, level_separator, "*")) { + class_name_end = level_separator; + } + + const Class log_class = GetClassByName(begin, class_name_end); + if (log_class == Class::Count) { + LOG_ERROR(Log, "Unknown log class in filter: %s", std::string(begin, end).c_str()); + return false; + } + + if (class_name_end == level_separator) { + SetClassLevel(log_class, level); + } + SetSubclassesLevel(log_class, level); + return true; +} + +bool Filter::CheckMessage(Class log_class, Level level) const { + return static_cast(level) >= static_cast(class_levels[static_cast(log_class)]); +} + +} diff --git a/src/common/logging/filter.h b/src/common/logging/filter.h new file mode 100644 index 0000000000..32b14b159b --- /dev/null +++ b/src/common/logging/filter.h @@ -0,0 +1,63 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2+ +// Refer to the license.txt file included. + +#include +#include + +#include "common/logging/log.h" + +namespace Log { + +struct ClassInfo; + +/** + * Implements a log message filter which allows different log classes to have different minimum + * severity levels. The filter can be changed at runtime and can be parsed from a string to allow + * editing via the interface or loading from a configuration file. + */ +class Filter { +public: + /// Initializes the filter with all classes having `default_level` as the minimum level. + Filter(Level default_level); + + /// Resets the filter so that all classes have `level` as the minimum displayed level. + void ResetAll(Level level); + /// Sets the minimum level of `log_class` (and not of its subclasses) to `level`. + void SetClassLevel(Class log_class, Level level); + /** + * Sets the minimum level of all of `log_class` subclasses to `level`. The level of `log_class` + * itself is not changed. + */ + void SetSubclassesLevel(const ClassInfo& log_class, Level level); + + /** + * Parses a filter string and applies it to this filter. + * + * A filter string consists of a space-separated list of filter rules, each of the format + * `:`. `` is a log class name, with subclasses separated using periods. + * A rule for a given class also affects all of its subclasses. `*` wildcards are allowed and + * can be used to apply a rule to all classes or to all subclasses of a class without affecting + * the parent class. `` a severity level name which will be set as the minimum logging + * level of the matched classes. Rules are applied left to right, with each rule overriding + * previous ones in the sequence. + * + * A few examples of filter rules: + * - `*:Info` -- Resets the level of all classes to Info. + * - `Service:Info` -- Sets the level of Service and all subclasses (Service.FS, Service.APT, + * etc.) to Info. + * - `Service.*:Debug` -- Sets the level of all Service subclasses to Debug, while leaving the + * level of Service unchanged. + * - `Service.FS:Trace` -- Sets the level of the Service.FS class to Trace. + */ + void ParseFilterString(const std::string& filter_str); + bool ParseFilterRule(const std::string::const_iterator start, const std::string::const_iterator end); + + /// Matches class/level combination against the filter, returning true if it passed. + bool CheckMessage(Class log_class, Level level) const; + +private: + std::array class_levels; +}; + +} diff --git a/src/common/logging/text_formatter.cpp b/src/common/logging/text_formatter.cpp index 88deb150e9..3fe435346e 100644 --- a/src/common/logging/text_formatter.cpp +++ b/src/common/logging/text_formatter.cpp @@ -11,6 +11,7 @@ #endif #include "common/logging/backend.h" +#include "common/logging/filter.h" #include "common/logging/log.h" #include "common/logging/text_formatter.h" @@ -105,7 +106,7 @@ void PrintMessage(const Entry& entry) { fputc('\n', stderr); } -void TextLoggingLoop(std::shared_ptr logger) { +void TextLoggingLoop(std::shared_ptr logger, const Filter* filter) { std::array entry_buffer; while (true) { @@ -114,7 +115,10 @@ void TextLoggingLoop(std::shared_ptr logger) { break; } for (size_t i = 0; i < num_entries; ++i) { - PrintMessage(entry_buffer[i]); + const Entry& entry = entry_buffer[i]; + if (filter->CheckMessage(entry.log_class, entry.log_level)) { + PrintMessage(entry); + } } } } diff --git a/src/common/logging/text_formatter.h b/src/common/logging/text_formatter.h index 04164600f2..d7e298e28b 100644 --- a/src/common/logging/text_formatter.h +++ b/src/common/logging/text_formatter.h @@ -11,6 +11,7 @@ namespace Log { class Logger; struct Entry; +class Filter; /** * Attempts to trim an arbitrary prefix from `path`, leaving only the part starting at `root`. It's @@ -33,6 +34,6 @@ void PrintMessage(const Entry& entry); * Logging loop that repeatedly reads messages from the provided logger and prints them to the * console. It is the baseline barebones log outputter. */ -void TextLoggingLoop(std::shared_ptr logger); +void TextLoggingLoop(std::shared_ptr logger, const Filter* filter); } diff --git a/src/core/settings.h b/src/core/settings.h index 7e7a66b89b..138ffc615d 100644 --- a/src/core/settings.h +++ b/src/core/settings.h @@ -4,6 +4,8 @@ #pragma once +#include + namespace Settings { struct Values { @@ -33,7 +35,7 @@ struct Values { // Data Storage bool use_virtual_sd; - bool enable_log; + std::string log_filter; } extern values; }