mirror of
https://github.com/yuzu-emu/yuzu.git
synced 2024-11-17 10:30:06 +00:00
135 lines
3.6 KiB
C++
135 lines
3.6 KiB
C++
// Copyright 2019 yuzu emulator team
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#include "common/assert.h"
|
|
#include "common/logging/log.h"
|
|
#include "common/string_util.h"
|
|
#include "core/hle/service/lm/manager.h"
|
|
#include "core/reporter.h"
|
|
|
|
namespace Service::LM {
|
|
|
|
std::ostream& operator<<(std::ostream& os, DestinationFlag dest) {
|
|
std::vector<std::string> array;
|
|
const auto check_single_flag = [dest, &array](DestinationFlag check, std::string name) {
|
|
if ((static_cast<u32>(check) & static_cast<u32>(dest)) != 0) {
|
|
array.emplace_back(std::move(name));
|
|
}
|
|
};
|
|
|
|
check_single_flag(DestinationFlag::Default, "Default");
|
|
check_single_flag(DestinationFlag::UART, "UART");
|
|
check_single_flag(DestinationFlag::UARTSleeping, "UART (Sleeping)");
|
|
|
|
os << "[";
|
|
for (const auto& entry : array) {
|
|
os << entry << ", ";
|
|
}
|
|
return os << "]";
|
|
}
|
|
|
|
std::ostream& operator<<(std::ostream& os, MessageHeader::Severity severity) {
|
|
switch (severity) {
|
|
case MessageHeader::Severity::Trace:
|
|
return os << "Trace";
|
|
case MessageHeader::Severity::Info:
|
|
return os << "Info";
|
|
case MessageHeader::Severity::Warning:
|
|
return os << "Warning";
|
|
case MessageHeader::Severity::Error:
|
|
return os << "Error";
|
|
case MessageHeader::Severity::Critical:
|
|
return os << "Critical";
|
|
default:
|
|
return os << fmt::format("{:08X}", static_cast<u32>(severity));
|
|
}
|
|
}
|
|
|
|
std::ostream& operator<<(std::ostream& os, Field field) {
|
|
switch (field) {
|
|
case Field::Skip:
|
|
return os << "Skip";
|
|
case Field::Message:
|
|
return os << "Message";
|
|
case Field::Line:
|
|
return os << "Line";
|
|
case Field::Filename:
|
|
return os << "Filename";
|
|
case Field::Function:
|
|
return os << "Function";
|
|
case Field::Module:
|
|
return os << "Module";
|
|
case Field::Thread:
|
|
return os << "Thread";
|
|
default:
|
|
return os << fmt::format("{:08X}", static_cast<u32>(field));
|
|
}
|
|
}
|
|
|
|
std::string FormatField(Field type, const std::vector<u8>& data) {
|
|
switch (type) {
|
|
case Field::Skip:
|
|
return "";
|
|
case Field::Line:
|
|
if (data.size() >= sizeof(u32)) {
|
|
u32 line;
|
|
std::memcpy(&line, data.data(), sizeof(u32));
|
|
return fmt::format("{}", line);
|
|
}
|
|
return "[ERROR DECODING LINE NUMBER]";
|
|
case Field::Message:
|
|
case Field::Filename:
|
|
case Field::Function:
|
|
case Field::Module:
|
|
case Field::Thread:
|
|
return Common::StringFromFixedZeroTerminatedBuffer(
|
|
reinterpret_cast<const char*>(data.data()), data.size());
|
|
default:
|
|
UNIMPLEMENTED_MSG("Unimplemented field type={}", type);
|
|
return "";
|
|
}
|
|
}
|
|
|
|
Manager::Manager(Core::Reporter& reporter) : reporter(reporter) {}
|
|
|
|
Manager::~Manager() = default;
|
|
|
|
void Manager::SetEnabled(bool enabled) {
|
|
this->enabled = enabled;
|
|
}
|
|
|
|
void Manager::SetDestination(DestinationFlag destination) {
|
|
this->destination = destination;
|
|
}
|
|
|
|
void Manager::Log(LogMessage message) {
|
|
if (message.header.IsHeadLog()) {
|
|
InitializeLog();
|
|
}
|
|
|
|
current_log.emplace_back(std::move(message));
|
|
|
|
if (current_log.back().header.IsTailLog()) {
|
|
FinalizeLog();
|
|
}
|
|
}
|
|
|
|
void Manager::Flush() {
|
|
FinalizeLog();
|
|
}
|
|
|
|
void Manager::InitializeLog() {
|
|
current_log.clear();
|
|
|
|
LOG_INFO(Service_LM, "Initialized new log session");
|
|
}
|
|
|
|
void Manager::FinalizeLog() {
|
|
reporter.SaveLogReport(static_cast<u32>(destination), std::move(current_log));
|
|
|
|
LOG_INFO(Service_LM, "Finalized current log session");
|
|
}
|
|
|
|
} // namespace Service::LM
|