From 2dde8f5cfe81648d05d60285ab5b17a6f61c486e Mon Sep 17 00:00:00 2001 From: Zach Hilman Date: Fri, 17 May 2019 21:45:56 -0400 Subject: core: Add Reporter class to take/save reports --- src/core/reporter.cpp | 351 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 351 insertions(+) create mode 100644 src/core/reporter.cpp (limited to 'src/core/reporter.cpp') diff --git a/src/core/reporter.cpp b/src/core/reporter.cpp new file mode 100644 index 000000000..95dcfffb5 --- /dev/null +++ b/src/core/reporter.cpp @@ -0,0 +1,351 @@ +// Copyright 2019 yuzu Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include +#include +#include "common/file_util.h" +#include "common/hex_util.h" +#include "common/scm_rev.h" +#include "core/arm/arm_interface.h" +#include "core/core.h" +#include "core/hle/kernel/hle_ipc.h" +#include "core/hle/kernel/process.h" +#include "core/reporter.h" +#include "core/settings.h" +#include "fmt/time.h" + +namespace { + +std::string GetPath(std::string_view type, u64 title_id, std::string_view timestamp) { + return fmt::format("{}{}/{:016X}_{}.json", FileUtil::GetUserPath(FileUtil::UserPath::LogDir), + type, title_id, timestamp); +} + +std::string GetTimestamp() { + const auto time = std::time(nullptr); + return fmt::format("{:%FT%H-%M-%S}", *std::localtime(&time)); +} + +using namespace nlohmann; + +void SaveToFile(const json& json, const std::string& filename) { + FileUtil::CreateFullPath(filename); + std::ofstream file( + FileUtil::SanitizePath(filename, FileUtil::DirectorySeparator::PlatformDefault)); + file << std::setw(4) << json << std::endl; + file.flush(); + file.close(); +} + +json GetYuzuVersionData() { + return { + {"scm_rev", std::string(Common::g_scm_rev)}, + {"scm_branch", std::string(Common::g_scm_branch)}, + {"scm_desc", std::string(Common::g_scm_desc)}, + {"build_name", std::string(Common::g_build_name)}, + {"build_date", std::string(Common::g_build_date)}, + {"build_fullname", std::string(Common::g_build_fullname)}, + {"build_version", std::string(Common::g_build_version)}, + {"shader_cache_version", std::string(Common::g_shader_cache_version)}, + }; +} + +json GetReportCommonData(u64 title_id, ResultCode result, const std::string& timestamp, + std::optional user_id = {}) { + auto out = json{ + {"title_id", fmt::format("{:016X}", title_id)}, + {"result_raw", fmt::format("{:08X}", result.raw)}, + {"result_module", fmt::format("{:08X}", static_cast(result.module.Value()))}, + {"result_description", fmt::format("{:08X}", result.description.Value())}, + {"timestamp", timestamp}, + }; + if (user_id.has_value()) + out["user_id"] = fmt::format("{:016X}{:016X}", (*user_id)[1], (*user_id)[0]); + return std::move(out); +} + +json GetProcessorStateData(const std::string& architecture, u64 entry_point, u64 sp, u64 pc, + u64 pstate, std::array registers, + std::optional> backtrace = {}) { + auto out = json{ + {"entry_point", fmt::format("{:016X}", entry_point)}, + {"sp", fmt::format("{:016X}", sp)}, + {"pc", fmt::format("{:016X}", pc)}, + {"pstate", fmt::format("{:016X}", pstate)}, + {"architecture", architecture}, + }; + + auto registers_out = json::object(); + for (std::size_t i = 0; i < registers.size(); ++i) { + registers_out[fmt::format("X{:02d}", i)] = fmt::format("{:016X}", registers[i]); + } + + out["registers"] = std::move(registers_out); + + if (backtrace.has_value()) { + auto backtrace_out = json::array(); + for (const auto& entry : *backtrace) { + backtrace_out.push_back(fmt::format("{:016X}", entry)); + } + out["backtrace"] = std::move(backtrace_out); + } + + return std::move(out); +} + +json GetProcessorStateDataAuto() { + const auto* process{Core::CurrentProcess()}; + const auto& vm_manager{process->VMManager()}; + auto& arm{Core::CurrentArmInterface()}; + + Core::ARM_Interface::ThreadContext context{}; + arm.SaveContext(context); + + return GetProcessorStateData(process->Is64BitProcess() ? "AArch64" : "AArch32", + vm_manager.GetCodeRegionBaseAddress(), context.sp, context.pc, + context.pstate, context.cpu_registers); +} + +json GetBacktraceData() { + auto out = json::array(); + const auto& backtrace{Core::CurrentArmInterface().GetBacktrace()}; + for (const auto& entry : backtrace) { + out.push_back({ + {"module", entry.module}, + {"address", fmt::format("{:016X}", entry.address)}, + {"original_address", fmt::format("{:016X}", entry.original_address)}, + {"offset", fmt::format("{:016X}", entry.offset)}, + {"symbol_name", entry.name}, + }); + } + + return std::move(out); +} + +json GetFullDataAuto(const std::string& timestamp, u64 title_id) { + json out; + + out["yuzu_version"] = GetYuzuVersionData(); + out["report_common"] = GetReportCommonData(title_id, RESULT_SUCCESS, timestamp); + out["processor_state"] = GetProcessorStateDataAuto(); + out["backtrace"] = GetBacktraceData(); + + return std::move(out); +} + +template +json GetHLEBufferDescriptorData(const std::vector& buffer) { + auto buffer_out = json::array(); + for (const auto& desc : buffer) { + auto entry = json{ + {"address", fmt::format("{:016X}", desc.Address())}, + {"size", fmt::format("{:016X}", desc.Size())}, + }; + + if constexpr (read_value) { + std::vector data(desc.Size()); + Memory::ReadBlock(desc.Address(), data.data(), desc.Size()); + entry["data"] = Common::HexVectorToString(data); + } + + buffer_out.push_back(std::move(entry)); + } + + return std::move(buffer_out); +} + +json GetHLERequestContextData(Kernel::HLERequestContext& ctx) { + json out; + + auto cmd_buf = json::array(); + for (std::size_t i = 0; i < IPC::COMMAND_BUFFER_LENGTH; ++i) { + cmd_buf.push_back(fmt::format("{:08X}", ctx.CommandBuffer()[i])); + } + + out["command_buffer"] = std::move(cmd_buf); + + out["buffer_descriptor_a"] = GetHLEBufferDescriptorData(ctx.BufferDescriptorA()); + out["buffer_descriptor_b"] = GetHLEBufferDescriptorData(ctx.BufferDescriptorB()); + out["buffer_descriptor_c"] = GetHLEBufferDescriptorData(ctx.BufferDescriptorC()); + out["buffer_descriptor_x"] = GetHLEBufferDescriptorData(ctx.BufferDescriptorX()); + + return std::move(out); +} + +} // Anonymous namespace + +namespace Core { + +Reporter::Reporter() = default; + +Reporter::~Reporter() = default; + +void Reporter::SaveCrashReport(u64 title_id, ResultCode result, u64 set_flags, u64 entry_point, + u64 sp, u64 pc, u64 pstate, u64 afsr0, u64 afsr1, u64 esr, u64 far, + const std::array& registers, + const std::array& backtrace, u32 backtrace_size, + const std::string& arch, u32 unk10) const { + if (!IsReportingEnabled()) + return; + + const auto timestamp{GetTimestamp()}; + json out; + + out["yuzu_version"] = GetYuzuVersionData(); + out["report_common"] = GetReportCommonData(title_id, result, timestamp); + + auto proc_out = GetProcessorStateData(arch, entry_point, sp, pc, pstate, registers, backtrace); + proc_out["set_flags"] = fmt::format("{:016X}", set_flags); + proc_out["afsr0"] = fmt::format("{:016X}", afsr0); + proc_out["afsr1"] = fmt::format("{:016X}", afsr1); + proc_out["esr"] = fmt::format("{:016X}", esr); + proc_out["far"] = fmt::format("{:016X}", far); + proc_out["backtrace_size"] = fmt::format("{:08X}", backtrace_size); + proc_out["unknown_10"] = fmt::format("{:08X}", unk10); + + out["processor_state"] = std::move(proc_out); + + SaveToFile(std::move(out), GetPath("crash_report", title_id, timestamp)); +} + +void Reporter::SaveSvcBreakReport(u32 type, bool signal_debugger, u64 info1, u64 info2, + std::optional> resolved_buffer) const { + if (!IsReportingEnabled()) + return; + + const auto timestamp{GetTimestamp()}; + const auto title_id{Core::CurrentProcess()->GetTitleID()}; + auto out = GetFullDataAuto(timestamp, title_id); + + auto break_out = json{ + {"type", fmt::format("{:08X}", type)}, + {"signal_debugger", fmt::format("{}", signal_debugger)}, + {"info1", fmt::format("{:016X}", info1)}, + {"info2", fmt::format("{:016X}", info2)}, + }; + + if (resolved_buffer.has_value()) { + break_out["debug_buffer"] = Common::HexVectorToString(*resolved_buffer); + } + + out["svc_break"] = std::move(break_out); + + SaveToFile(std::move(out), GetPath("svc_break_report", title_id, timestamp)); +} + +void Reporter::SaveUnimplementedFunctionReport(Kernel::HLERequestContext& ctx, u32 command_id, + const std::string& name, + const std::string& service_name) const { + if (!IsReportingEnabled()) + return; + + const auto timestamp{GetTimestamp()}; + const auto title_id{Core::CurrentProcess()->GetTitleID()}; + auto out = GetFullDataAuto(timestamp, title_id); + + auto function_out = GetHLERequestContextData(ctx); + function_out["command_id"] = command_id; + function_out["function_name"] = name; + function_out["service_name"] = service_name; + + out["function"] = std::move(function_out); + + SaveToFile(std::move(out), GetPath("unimpl_func_report", title_id, timestamp)); +} + +void Reporter::SaveUnimplementedAppletReport( + u32 applet_id, u32 common_args_version, u32 library_version, u32 theme_color, + bool startup_sound, u64 system_tick, std::vector> normal_channel, + std::vector> interactive_channel) const { + if (!IsReportingEnabled()) + return; + + const auto timestamp{GetTimestamp()}; + const auto title_id{Core::CurrentProcess()->GetTitleID()}; + auto out = GetFullDataAuto(timestamp, title_id); + + out["applet_common_args"] = { + {"applet_id", fmt::format("{:02X}", applet_id)}, + {"common_args_version", fmt::format("{:08X}", common_args_version)}, + {"library_version", fmt::format("{:08X}", library_version)}, + {"theme_color", fmt::format("{:08X}", theme_color)}, + {"startup_sound", fmt::format("{}", startup_sound)}, + {"system_tick", fmt::format("{:016X}", system_tick)}, + }; + + auto normal_out = json::array(); + for (const auto& data : normal_channel) { + normal_out.push_back(Common::HexVectorToString(data)); + } + + auto interactive_out = json::array(); + for (const auto& data : interactive_channel) { + interactive_out.push_back(Common::HexVectorToString(data)); + } + + out["applet_normal_data"] = std::move(normal_out); + out["applet_interactive_data"] = std::move(interactive_out); + + SaveToFile(std::move(out), GetPath("unimpl_applet_report", title_id, timestamp)); +} + +void Reporter::SavePlayReport(u64 title_id, u64 unk1, std::vector> data, + std::optional user_id) const { + if (!IsReportingEnabled()) + return; + + const auto timestamp{GetTimestamp()}; + json out; + + out["yuzu_version"] = GetYuzuVersionData(); + out["report_common"] = GetReportCommonData(title_id, RESULT_SUCCESS, timestamp, user_id); + + auto data_out = json::array(); + for (const auto& d : data) { + data_out.push_back(Common::HexVectorToString(d)); + } + + out["play_report_unk1"] = fmt::format("{:016X}", unk1); + out["play_report_data"] = std::move(data_out); + + SaveToFile(std::move(out), GetPath("play_report", title_id, timestamp)); +} + +void Reporter::SaveErrorReport(u64 title_id, ResultCode result, + std::optional custom_text_main, + std::optional custom_text_detail) const { + if (!IsReportingEnabled()) + return; + + const auto timestamp{GetTimestamp()}; + json out; + + out["yuzu_version"] = GetYuzuVersionData(); + out["report_common"] = GetReportCommonData(title_id, result, timestamp); + out["processor_state"] = GetProcessorStateDataAuto(); + out["backtrace"] = GetBacktraceData(); + + out["error_custom_text"] = { + {"main", *custom_text_main}, + {"detail", *custom_text_detail}, + }; + + SaveToFile(std::move(out), GetPath("error_report", title_id, timestamp)); +} + +void Reporter::SaveUserReport() const { + if (!IsReportingEnabled()) + return; + + const auto timestamp{GetTimestamp()}; + const auto title_id{Core::CurrentProcess()->GetTitleID()}; + + SaveToFile(GetFullDataAuto(timestamp, title_id), GetPath("user_report", title_id, timestamp)); +} + +bool Reporter::IsReportingEnabled() const { + return Settings::values.reporting_services; +} + +} // namespace Core -- cgit v1.2.3 From b77fde7c5c1f63aad9d4f01ea625805661870f3e Mon Sep 17 00:00:00 2001 From: Zach Hilman Date: Sun, 26 May 2019 11:40:41 -0400 Subject: loader: Move NSO module tracking to AppLoader Also cleanup of general stuff --- src/core/reporter.cpp | 74 ++++++++++++++++++++++++++------------------------- 1 file changed, 38 insertions(+), 36 deletions(-) (limited to 'src/core/reporter.cpp') diff --git a/src/core/reporter.cpp b/src/core/reporter.cpp index 95dcfffb5..8fe621aa0 100644 --- a/src/core/reporter.cpp +++ b/src/core/reporter.cpp @@ -11,6 +11,7 @@ #include "core/core.h" #include "core/hle/kernel/hle_ipc.h" #include "core/hle/kernel/process.h" +#include "core/hle/result.h" #include "core/reporter.h" #include "core/settings.h" #include "fmt/time.h" @@ -30,12 +31,12 @@ std::string GetTimestamp() { using namespace nlohmann; void SaveToFile(const json& json, const std::string& filename) { - FileUtil::CreateFullPath(filename); + if (!FileUtil::CreateFullPath(filename)) + LOG_ERROR(Core, "Failed to create path for '{}' to save report!", filename); + std::ofstream file( FileUtil::SanitizePath(filename, FileUtil::DirectorySeparator::PlatformDefault)); file << std::setw(4) << json << std::endl; - file.flush(); - file.close(); } json GetYuzuVersionData() { @@ -62,7 +63,7 @@ json GetReportCommonData(u64 title_id, ResultCode result, const std::string& tim }; if (user_id.has_value()) out["user_id"] = fmt::format("{:016X}{:016X}", (*user_id)[1], (*user_id)[0]); - return std::move(out); + return out; } json GetProcessorStateData(const std::string& architecture, u64 entry_point, u64 sp, u64 pc, @@ -91,13 +92,13 @@ json GetProcessorStateData(const std::string& architecture, u64 entry_point, u64 out["backtrace"] = std::move(backtrace_out); } - return std::move(out); + return out; } -json GetProcessorStateDataAuto() { - const auto* process{Core::CurrentProcess()}; +json GetProcessorStateDataAuto(Core::System& system) { + const auto* process{system.CurrentProcess()}; const auto& vm_manager{process->VMManager()}; - auto& arm{Core::CurrentArmInterface()}; + auto& arm{system.CurrentArmInterface()}; Core::ARM_Interface::ThreadContext context{}; arm.SaveContext(context); @@ -107,9 +108,9 @@ json GetProcessorStateDataAuto() { context.pstate, context.cpu_registers); } -json GetBacktraceData() { +json GetBacktraceData(Core::System& system) { auto out = json::array(); - const auto& backtrace{Core::CurrentArmInterface().GetBacktrace()}; + const auto& backtrace{system.CurrentArmInterface().GetBacktrace()}; for (const auto& entry : backtrace) { out.push_back({ {"module", entry.module}, @@ -120,18 +121,18 @@ json GetBacktraceData() { }); } - return std::move(out); + return out; } -json GetFullDataAuto(const std::string& timestamp, u64 title_id) { +json GetFullDataAuto(const std::string& timestamp, u64 title_id, Core::System& system) { json out; out["yuzu_version"] = GetYuzuVersionData(); out["report_common"] = GetReportCommonData(title_id, RESULT_SUCCESS, timestamp); - out["processor_state"] = GetProcessorStateDataAuto(); - out["backtrace"] = GetBacktraceData(); + out["processor_state"] = GetProcessorStateDataAuto(system); + out["backtrace"] = GetBacktraceData(system); - return std::move(out); + return out; } template @@ -152,7 +153,7 @@ json GetHLEBufferDescriptorData(const std::vector& buffer) { buffer_out.push_back(std::move(entry)); } - return std::move(buffer_out); + return buffer_out; } json GetHLERequestContextData(Kernel::HLERequestContext& ctx) { @@ -177,7 +178,7 @@ json GetHLERequestContextData(Kernel::HLERequestContext& ctx) { namespace Core { -Reporter::Reporter() = default; +Reporter::Reporter(Core::System& system) : system(system) {} Reporter::~Reporter() = default; @@ -189,7 +190,7 @@ void Reporter::SaveCrashReport(u64 title_id, ResultCode result, u64 set_flags, u if (!IsReportingEnabled()) return; - const auto timestamp{GetTimestamp()}; + const auto timestamp = GetTimestamp(); json out; out["yuzu_version"] = GetYuzuVersionData(); @@ -214,9 +215,9 @@ void Reporter::SaveSvcBreakReport(u32 type, bool signal_debugger, u64 info1, u64 if (!IsReportingEnabled()) return; - const auto timestamp{GetTimestamp()}; - const auto title_id{Core::CurrentProcess()->GetTitleID()}; - auto out = GetFullDataAuto(timestamp, title_id); + const auto timestamp = GetTimestamp(); + const auto title_id = system.CurrentProcess()->GetTitleID(); + auto out = GetFullDataAuto(timestamp, title_id, system); auto break_out = json{ {"type", fmt::format("{:08X}", type)}, @@ -240,9 +241,9 @@ void Reporter::SaveUnimplementedFunctionReport(Kernel::HLERequestContext& ctx, u if (!IsReportingEnabled()) return; - const auto timestamp{GetTimestamp()}; - const auto title_id{Core::CurrentProcess()->GetTitleID()}; - auto out = GetFullDataAuto(timestamp, title_id); + const auto timestamp = GetTimestamp(); + const auto title_id = system.CurrentProcess()->GetTitleID(); + auto out = GetFullDataAuto(timestamp, title_id, system); auto function_out = GetHLERequestContextData(ctx); function_out["command_id"] = command_id; @@ -261,9 +262,9 @@ void Reporter::SaveUnimplementedAppletReport( if (!IsReportingEnabled()) return; - const auto timestamp{GetTimestamp()}; - const auto title_id{Core::CurrentProcess()->GetTitleID()}; - auto out = GetFullDataAuto(timestamp, title_id); + const auto timestamp = GetTimestamp(); + const auto title_id = system.CurrentProcess()->GetTitleID(); + auto out = GetFullDataAuto(timestamp, title_id, system); out["applet_common_args"] = { {"applet_id", fmt::format("{:02X}", applet_id)}, @@ -290,12 +291,12 @@ void Reporter::SaveUnimplementedAppletReport( SaveToFile(std::move(out), GetPath("unimpl_applet_report", title_id, timestamp)); } -void Reporter::SavePlayReport(u64 title_id, u64 unk1, std::vector> data, +void Reporter::SavePlayReport(u64 title_id, u64 process_id, std::vector> data, std::optional user_id) const { if (!IsReportingEnabled()) return; - const auto timestamp{GetTimestamp()}; + const auto timestamp = GetTimestamp(); json out; out["yuzu_version"] = GetYuzuVersionData(); @@ -306,7 +307,7 @@ void Reporter::SavePlayReport(u64 title_id, u64 unk1, std::vectorGetTitleID()}; + const auto timestamp = GetTimestamp(); + const auto title_id = system.CurrentProcess()->GetTitleID(); - SaveToFile(GetFullDataAuto(timestamp, title_id), GetPath("user_report", title_id, timestamp)); + SaveToFile(GetFullDataAuto(timestamp, title_id, system), + GetPath("user_report", title_id, timestamp)); } bool Reporter::IsReportingEnabled() const { -- cgit v1.2.3