1 // Copyright 2019 yuzu Emulator Project
2 // Licensed under GPLv2 or any later version
3 // Refer to the license.txt file included.
4
5 #include <ctime>
6 #include <fstream>
7 #include <iomanip>
8
9 #include <fmt/chrono.h>
10 #include <fmt/format.h>
11 #include <fmt/ostream.h>
12 #include <nlohmann/json.hpp>
13
14 #include "common/file_util.h"
15 #include "common/hex_util.h"
16 #include "common/scm_rev.h"
17 #include "core/arm/arm_interface.h"
18 #include "core/core.h"
19 #include "core/hle/kernel/hle_ipc.h"
20 #include "core/hle/kernel/memory/page_table.h"
21 #include "core/hle/kernel/process.h"
22 #include "core/hle/result.h"
23 #include "core/hle/service/lm/manager.h"
24 #include "core/memory.h"
25 #include "core/reporter.h"
26 #include "core/settings.h"
27
28 namespace {
29
GetPath(std::string_view type,u64 title_id,std::string_view timestamp)30 std::string GetPath(std::string_view type, u64 title_id, std::string_view timestamp) {
31 return fmt::format("{}{}/{:016X}_{}.json",
32 Common::FS::GetUserPath(Common::FS::UserPath::LogDir), type, title_id,
33 timestamp);
34 }
35
GetTimestamp()36 std::string GetTimestamp() {
37 const auto time = std::time(nullptr);
38 return fmt::format("{:%FT%H-%M-%S}", *std::localtime(&time));
39 }
40
41 using namespace nlohmann;
42
SaveToFile(json json,const std::string & filename)43 void SaveToFile(json json, const std::string& filename) {
44 if (!Common::FS::CreateFullPath(filename)) {
45 LOG_ERROR(Core, "Failed to create path for '{}' to save report!", filename);
46 return;
47 }
48
49 std::ofstream file(
50 Common::FS::SanitizePath(filename, Common::FS::DirectorySeparator::PlatformDefault));
51 file << std::setw(4) << json << std::endl;
52 }
53
GetYuzuVersionData()54 json GetYuzuVersionData() {
55 return {
56 {"scm_rev", std::string(Common::g_scm_rev)},
57 {"scm_branch", std::string(Common::g_scm_branch)},
58 {"scm_desc", std::string(Common::g_scm_desc)},
59 {"build_name", std::string(Common::g_build_name)},
60 {"build_date", std::string(Common::g_build_date)},
61 {"build_fullname", std::string(Common::g_build_fullname)},
62 {"build_version", std::string(Common::g_build_version)},
63 {"shader_cache_version", std::string(Common::g_shader_cache_version)},
64 };
65 }
66
GetReportCommonData(u64 title_id,ResultCode result,const std::string & timestamp,std::optional<u128> user_id={})67 json GetReportCommonData(u64 title_id, ResultCode result, const std::string& timestamp,
68 std::optional<u128> user_id = {}) {
69 auto out = json{
70 {"title_id", fmt::format("{:016X}", title_id)},
71 {"result_raw", fmt::format("{:08X}", result.raw)},
72 {"result_module", fmt::format("{:08X}", static_cast<u32>(result.module.Value()))},
73 {"result_description", fmt::format("{:08X}", result.description.Value())},
74 {"timestamp", timestamp},
75 };
76
77 if (user_id.has_value()) {
78 out["user_id"] = fmt::format("{:016X}{:016X}", (*user_id)[1], (*user_id)[0]);
79 }
80
81 return out;
82 }
83
GetProcessorStateData(const std::string & architecture,u64 entry_point,u64 sp,u64 pc,u64 pstate,std::array<u64,31> registers,std::optional<std::array<u64,32>> backtrace={})84 json GetProcessorStateData(const std::string& architecture, u64 entry_point, u64 sp, u64 pc,
85 u64 pstate, std::array<u64, 31> registers,
86 std::optional<std::array<u64, 32>> backtrace = {}) {
87 auto out = json{
88 {"entry_point", fmt::format("{:016X}", entry_point)},
89 {"sp", fmt::format("{:016X}", sp)},
90 {"pc", fmt::format("{:016X}", pc)},
91 {"pstate", fmt::format("{:016X}", pstate)},
92 {"architecture", architecture},
93 };
94
95 auto registers_out = json::object();
96 for (std::size_t i = 0; i < registers.size(); ++i) {
97 registers_out[fmt::format("X{:02d}", i)] = fmt::format("{:016X}", registers[i]);
98 }
99
100 out["registers"] = std::move(registers_out);
101
102 if (backtrace.has_value()) {
103 auto backtrace_out = json::array();
104 for (const auto& entry : *backtrace) {
105 backtrace_out.push_back(fmt::format("{:016X}", entry));
106 }
107 out["backtrace"] = std::move(backtrace_out);
108 }
109
110 return out;
111 }
112
GetProcessorStateDataAuto(Core::System & system)113 json GetProcessorStateDataAuto(Core::System& system) {
114 const auto* process{system.CurrentProcess()};
115 auto& arm{system.CurrentArmInterface()};
116
117 Core::ARM_Interface::ThreadContext64 context{};
118 arm.SaveContext(context);
119
120 return GetProcessorStateData(process->Is64BitProcess() ? "AArch64" : "AArch32",
121 process->PageTable().GetCodeRegionStart(), context.sp, context.pc,
122 context.pstate, context.cpu_registers);
123 }
124
GetBacktraceData(Core::System & system)125 json GetBacktraceData(Core::System& system) {
126 auto out = json::array();
127 const auto& backtrace{system.CurrentArmInterface().GetBacktrace()};
128 for (const auto& entry : backtrace) {
129 out.push_back({
130 {"module", entry.module},
131 {"address", fmt::format("{:016X}", entry.address)},
132 {"original_address", fmt::format("{:016X}", entry.original_address)},
133 {"offset", fmt::format("{:016X}", entry.offset)},
134 {"symbol_name", entry.name},
135 });
136 }
137
138 return out;
139 }
140
GetFullDataAuto(const std::string & timestamp,u64 title_id,Core::System & system)141 json GetFullDataAuto(const std::string& timestamp, u64 title_id, Core::System& system) {
142 json out;
143
144 out["yuzu_version"] = GetYuzuVersionData();
145 out["report_common"] = GetReportCommonData(title_id, RESULT_SUCCESS, timestamp);
146 out["processor_state"] = GetProcessorStateDataAuto(system);
147 out["backtrace"] = GetBacktraceData(system);
148
149 return out;
150 }
151
152 template <bool read_value, typename DescriptorType>
GetHLEBufferDescriptorData(const std::vector<DescriptorType> & buffer,Core::Memory::Memory & memory)153 json GetHLEBufferDescriptorData(const std::vector<DescriptorType>& buffer,
154 Core::Memory::Memory& memory) {
155 auto buffer_out = json::array();
156 for (const auto& desc : buffer) {
157 auto entry = json{
158 {"address", fmt::format("{:016X}", desc.Address())},
159 {"size", fmt::format("{:016X}", desc.Size())},
160 };
161
162 if constexpr (read_value) {
163 std::vector<u8> data(desc.Size());
164 memory.ReadBlock(desc.Address(), data.data(), desc.Size());
165 entry["data"] = Common::HexToString(data);
166 }
167
168 buffer_out.push_back(std::move(entry));
169 }
170
171 return buffer_out;
172 }
173
GetHLERequestContextData(Kernel::HLERequestContext & ctx,Core::Memory::Memory & memory)174 json GetHLERequestContextData(Kernel::HLERequestContext& ctx, Core::Memory::Memory& memory) {
175 json out;
176
177 auto cmd_buf = json::array();
178 for (std::size_t i = 0; i < IPC::COMMAND_BUFFER_LENGTH; ++i) {
179 cmd_buf.push_back(fmt::format("{:08X}", ctx.CommandBuffer()[i]));
180 }
181
182 out["command_buffer"] = std::move(cmd_buf);
183
184 out["buffer_descriptor_a"] = GetHLEBufferDescriptorData<true>(ctx.BufferDescriptorA(), memory);
185 out["buffer_descriptor_b"] = GetHLEBufferDescriptorData<false>(ctx.BufferDescriptorB(), memory);
186 out["buffer_descriptor_c"] = GetHLEBufferDescriptorData<false>(ctx.BufferDescriptorC(), memory);
187 out["buffer_descriptor_x"] = GetHLEBufferDescriptorData<true>(ctx.BufferDescriptorX(), memory);
188
189 return out;
190 }
191
192 } // Anonymous namespace
193
194 namespace Core {
195
Reporter(System & system)196 Reporter::Reporter(System& system) : system(system) {}
197
198 Reporter::~Reporter() = default;
199
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<u64,31> & registers,const std::array<u64,32> & backtrace,u32 backtrace_size,const std::string & arch,u32 unk10) const200 void Reporter::SaveCrashReport(u64 title_id, ResultCode result, u64 set_flags, u64 entry_point,
201 u64 sp, u64 pc, u64 pstate, u64 afsr0, u64 afsr1, u64 esr, u64 far,
202 const std::array<u64, 31>& registers,
203 const std::array<u64, 32>& backtrace, u32 backtrace_size,
204 const std::string& arch, u32 unk10) const {
205 if (!IsReportingEnabled()) {
206 return;
207 }
208
209 const auto timestamp = GetTimestamp();
210 json out;
211
212 out["yuzu_version"] = GetYuzuVersionData();
213 out["report_common"] = GetReportCommonData(title_id, result, timestamp);
214
215 auto proc_out = GetProcessorStateData(arch, entry_point, sp, pc, pstate, registers, backtrace);
216 proc_out["set_flags"] = fmt::format("{:016X}", set_flags);
217 proc_out["afsr0"] = fmt::format("{:016X}", afsr0);
218 proc_out["afsr1"] = fmt::format("{:016X}", afsr1);
219 proc_out["esr"] = fmt::format("{:016X}", esr);
220 proc_out["far"] = fmt::format("{:016X}", far);
221 proc_out["backtrace_size"] = fmt::format("{:08X}", backtrace_size);
222 proc_out["unknown_10"] = fmt::format("{:08X}", unk10);
223
224 out["processor_state"] = std::move(proc_out);
225
226 SaveToFile(std::move(out), GetPath("crash_report", title_id, timestamp));
227 }
228
SaveSvcBreakReport(u32 type,bool signal_debugger,u64 info1,u64 info2,std::optional<std::vector<u8>> resolved_buffer) const229 void Reporter::SaveSvcBreakReport(u32 type, bool signal_debugger, u64 info1, u64 info2,
230 std::optional<std::vector<u8>> resolved_buffer) const {
231 if (!IsReportingEnabled()) {
232 return;
233 }
234
235 const auto timestamp = GetTimestamp();
236 const auto title_id = system.CurrentProcess()->GetTitleID();
237 auto out = GetFullDataAuto(timestamp, title_id, system);
238
239 auto break_out = json{
240 {"type", fmt::format("{:08X}", type)},
241 {"signal_debugger", fmt::format("{}", signal_debugger)},
242 {"info1", fmt::format("{:016X}", info1)},
243 {"info2", fmt::format("{:016X}", info2)},
244 };
245
246 if (resolved_buffer.has_value()) {
247 break_out["debug_buffer"] = Common::HexToString(*resolved_buffer);
248 }
249
250 out["svc_break"] = std::move(break_out);
251
252 SaveToFile(std::move(out), GetPath("svc_break_report", title_id, timestamp));
253 }
254
SaveUnimplementedFunctionReport(Kernel::HLERequestContext & ctx,u32 command_id,const std::string & name,const std::string & service_name) const255 void Reporter::SaveUnimplementedFunctionReport(Kernel::HLERequestContext& ctx, u32 command_id,
256 const std::string& name,
257 const std::string& service_name) const {
258 if (!IsReportingEnabled()) {
259 return;
260 }
261
262 const auto timestamp = GetTimestamp();
263 const auto title_id = system.CurrentProcess()->GetTitleID();
264 auto out = GetFullDataAuto(timestamp, title_id, system);
265
266 auto function_out = GetHLERequestContextData(ctx, system.Memory());
267 function_out["command_id"] = command_id;
268 function_out["function_name"] = name;
269 function_out["service_name"] = service_name;
270
271 out["function"] = std::move(function_out);
272
273 SaveToFile(std::move(out), GetPath("unimpl_func_report", title_id, timestamp));
274 }
275
SaveUnimplementedAppletReport(u32 applet_id,u32 common_args_version,u32 library_version,u32 theme_color,bool startup_sound,u64 system_tick,std::vector<std::vector<u8>> normal_channel,std::vector<std::vector<u8>> interactive_channel) const276 void Reporter::SaveUnimplementedAppletReport(
277 u32 applet_id, u32 common_args_version, u32 library_version, u32 theme_color,
278 bool startup_sound, u64 system_tick, std::vector<std::vector<u8>> normal_channel,
279 std::vector<std::vector<u8>> interactive_channel) const {
280 if (!IsReportingEnabled()) {
281 return;
282 }
283
284 const auto timestamp = GetTimestamp();
285 const auto title_id = system.CurrentProcess()->GetTitleID();
286 auto out = GetFullDataAuto(timestamp, title_id, system);
287
288 out["applet_common_args"] = {
289 {"applet_id", fmt::format("{:02X}", applet_id)},
290 {"common_args_version", fmt::format("{:08X}", common_args_version)},
291 {"library_version", fmt::format("{:08X}", library_version)},
292 {"theme_color", fmt::format("{:08X}", theme_color)},
293 {"startup_sound", fmt::format("{}", startup_sound)},
294 {"system_tick", fmt::format("{:016X}", system_tick)},
295 };
296
297 auto normal_out = json::array();
298 for (const auto& data : normal_channel) {
299 normal_out.push_back(Common::HexToString(data));
300 }
301
302 auto interactive_out = json::array();
303 for (const auto& data : interactive_channel) {
304 interactive_out.push_back(Common::HexToString(data));
305 }
306
307 out["applet_normal_data"] = std::move(normal_out);
308 out["applet_interactive_data"] = std::move(interactive_out);
309
310 SaveToFile(std::move(out), GetPath("unimpl_applet_report", title_id, timestamp));
311 }
312
SavePlayReport(PlayReportType type,u64 title_id,std::vector<std::vector<u8>> data,std::optional<u64> process_id,std::optional<u128> user_id) const313 void Reporter::SavePlayReport(PlayReportType type, u64 title_id, std::vector<std::vector<u8>> data,
314 std::optional<u64> process_id, std::optional<u128> user_id) const {
315 if (!IsReportingEnabled()) {
316 return;
317 }
318
319 const auto timestamp = GetTimestamp();
320 json out;
321
322 out["yuzu_version"] = GetYuzuVersionData();
323 out["report_common"] = GetReportCommonData(title_id, RESULT_SUCCESS, timestamp, user_id);
324
325 auto data_out = json::array();
326 for (const auto& d : data) {
327 data_out.push_back(Common::HexToString(d));
328 }
329
330 if (process_id.has_value()) {
331 out["play_report_process_id"] = fmt::format("{:016X}", *process_id);
332 }
333
334 out["play_report_type"] = fmt::format("{:02}", static_cast<u8>(type));
335 out["play_report_data"] = std::move(data_out);
336
337 SaveToFile(std::move(out), GetPath("play_report", title_id, timestamp));
338 }
339
SaveErrorReport(u64 title_id,ResultCode result,std::optional<std::string> custom_text_main,std::optional<std::string> custom_text_detail) const340 void Reporter::SaveErrorReport(u64 title_id, ResultCode result,
341 std::optional<std::string> custom_text_main,
342 std::optional<std::string> custom_text_detail) const {
343 if (!IsReportingEnabled()) {
344 return;
345 }
346
347 const auto timestamp = GetTimestamp();
348 json out;
349
350 out["yuzu_version"] = GetYuzuVersionData();
351 out["report_common"] = GetReportCommonData(title_id, result, timestamp);
352 out["processor_state"] = GetProcessorStateDataAuto(system);
353 out["backtrace"] = GetBacktraceData(system);
354
355 out["error_custom_text"] = {
356 {"main", *custom_text_main},
357 {"detail", *custom_text_detail},
358 };
359
360 SaveToFile(std::move(out), GetPath("error_report", title_id, timestamp));
361 }
362
SaveLogReport(u32 destination,std::vector<Service::LM::LogMessage> messages) const363 void Reporter::SaveLogReport(u32 destination, std::vector<Service::LM::LogMessage> messages) const {
364 if (!IsReportingEnabled()) {
365 return;
366 }
367
368 const auto timestamp = GetTimestamp();
369 json out;
370
371 out["yuzu_version"] = GetYuzuVersionData();
372 out["report_common"] =
373 GetReportCommonData(system.CurrentProcess()->GetTitleID(), RESULT_SUCCESS, timestamp);
374
375 out["log_destination"] =
376 fmt::format("{}", static_cast<Service::LM::DestinationFlag>(destination));
377
378 auto json_messages = json::array();
379 std::transform(messages.begin(), messages.end(), std::back_inserter(json_messages),
380 [](const Service::LM::LogMessage& message) {
381 json out;
382 out["is_head"] = fmt::format("{}", message.header.IsHeadLog());
383 out["is_tail"] = fmt::format("{}", message.header.IsTailLog());
384 out["pid"] = fmt::format("{:016X}", message.header.pid);
385 out["thread_context"] =
386 fmt::format("{:016X}", message.header.thread_context);
387 out["payload_size"] = fmt::format("{:016X}", message.header.payload_size);
388 out["flags"] = fmt::format("{:04X}", message.header.flags.Value());
389 out["severity"] = fmt::format("{}", message.header.severity.Value());
390 out["verbosity"] = fmt::format("{:02X}", message.header.verbosity);
391
392 auto fields = json::array();
393 std::transform(message.fields.begin(), message.fields.end(),
394 std::back_inserter(fields), [](const auto& kv) {
395 json out;
396 out["type"] = fmt::format("{}", kv.first);
397 out["data"] =
398 Service::LM::FormatField(kv.first, kv.second);
399 return out;
400 });
401
402 out["fields"] = std::move(fields);
403 return out;
404 });
405
406 out["log_messages"] = std::move(json_messages);
407
408 SaveToFile(std::move(out),
409 GetPath("log_report", system.CurrentProcess()->GetTitleID(), timestamp));
410 }
411
SaveFilesystemAccessReport(Service::FileSystem::LogMode log_mode,std::string log_message) const412 void Reporter::SaveFilesystemAccessReport(Service::FileSystem::LogMode log_mode,
413 std::string log_message) const {
414 if (!IsReportingEnabled())
415 return;
416
417 const auto timestamp = GetTimestamp();
418 const auto title_id = system.CurrentProcess()->GetTitleID();
419 json out;
420
421 out["yuzu_version"] = GetYuzuVersionData();
422 out["report_common"] = GetReportCommonData(title_id, RESULT_SUCCESS, timestamp);
423
424 out["log_mode"] = fmt::format("{:08X}", static_cast<u32>(log_mode));
425 out["log_message"] = std::move(log_message);
426
427 SaveToFile(std::move(out), GetPath("filesystem_access_report", title_id, timestamp));
428 }
429
SaveUserReport() const430 void Reporter::SaveUserReport() const {
431 if (!IsReportingEnabled()) {
432 return;
433 }
434
435 const auto timestamp = GetTimestamp();
436 const auto title_id = system.CurrentProcess()->GetTitleID();
437
438 SaveToFile(GetFullDataAuto(timestamp, title_id, system),
439 GetPath("user_report", title_id, timestamp));
440 }
441
IsReportingEnabled() const442 bool Reporter::IsReportingEnabled() const {
443 return Settings::values.reporting_services;
444 }
445
446 } // namespace Core
447