2018-01-13 13:22:39 -08:00
|
|
|
// Copyright 2018 yuzu emulator team
|
2017-10-14 19:18:42 -07:00
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2017-10-18 18:41:24 -07:00
|
|
|
#include <string>
|
2017-10-14 19:18:42 -07:00
|
|
|
#include "common/logging/log.h"
|
|
|
|
#include "core/hle/ipc_helpers.h"
|
2017-10-18 18:41:24 -07:00
|
|
|
#include "core/hle/kernel/client_session.h"
|
2017-10-14 19:18:42 -07:00
|
|
|
#include "core/hle/service/lm/lm.h"
|
|
|
|
|
|
|
|
namespace Service {
|
|
|
|
namespace LM {
|
|
|
|
|
2017-10-18 18:41:24 -07:00
|
|
|
class Logger final : public ServiceFramework<Logger> {
|
|
|
|
public:
|
|
|
|
Logger() : ServiceFramework("Logger") {
|
|
|
|
static const FunctionInfo functions[] = {
|
|
|
|
{0x00000000, &Logger::Log, "Log"},
|
|
|
|
};
|
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
|
|
|
|
|
|
|
~Logger() = default;
|
|
|
|
|
|
|
|
private:
|
|
|
|
struct MessageHeader {
|
2018-01-04 21:45:13 -08:00
|
|
|
enum Flags : u32_le {
|
|
|
|
IsHead = 1,
|
|
|
|
IsTail = 2,
|
|
|
|
};
|
|
|
|
|
2017-10-18 18:41:24 -07:00
|
|
|
u64_le pid;
|
|
|
|
u64_le threadContext;
|
|
|
|
union {
|
2018-01-04 21:45:13 -08:00
|
|
|
BitField<0, 16, Flags> flags;
|
2017-10-18 18:41:24 -07:00
|
|
|
BitField<16, 8, u32_le> severity;
|
|
|
|
BitField<24, 8, u32_le> verbosity;
|
|
|
|
};
|
|
|
|
u32_le payload_size;
|
2018-01-06 11:41:56 -08:00
|
|
|
|
|
|
|
/// Returns true if this is part of a single log message
|
|
|
|
bool IsSingleMessage() const {
|
|
|
|
return (flags & Flags::IsHead) && (flags & Flags::IsTail);
|
|
|
|
}
|
2017-10-18 18:41:24 -07:00
|
|
|
};
|
2018-01-04 21:45:13 -08:00
|
|
|
static_assert(sizeof(MessageHeader) == 0x18, "MessageHeader is incorrect size");
|
|
|
|
|
|
|
|
/// Log field type
|
|
|
|
enum class Field : u8 {
|
|
|
|
Message = 2,
|
|
|
|
Line = 3,
|
|
|
|
Filename = 4,
|
|
|
|
Function = 5,
|
|
|
|
Module = 6,
|
|
|
|
Thread = 7,
|
|
|
|
};
|
2017-10-18 18:41:24 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* LM::Initialize service function
|
|
|
|
* Inputs:
|
|
|
|
* 0: 0x00000000
|
|
|
|
* Outputs:
|
|
|
|
* 0: ResultCode
|
|
|
|
*/
|
|
|
|
void Log(Kernel::HLERequestContext& ctx) {
|
2018-01-04 21:45:13 -08:00
|
|
|
// This function only succeeds - Get that out of the way
|
|
|
|
IPC::RequestBuilder rb{ctx, 1};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
|
|
|
|
// Read MessageHeader, despite not doing anything with it right now
|
2017-10-18 18:41:24 -07:00
|
|
|
MessageHeader header{};
|
2018-01-04 21:45:13 -08:00
|
|
|
VAddr addr{ctx.BufferDescriptorX()[0].Address()};
|
|
|
|
const VAddr end_addr{addr + ctx.BufferDescriptorX()[0].size};
|
|
|
|
Memory::ReadBlock(addr, &header, sizeof(MessageHeader));
|
|
|
|
addr += sizeof(MessageHeader);
|
2017-10-18 18:41:24 -07:00
|
|
|
|
2018-01-06 11:41:56 -08:00
|
|
|
if (!header.IsSingleMessage()) {
|
2018-01-09 12:14:21 -08:00
|
|
|
LOG_WARNING(Service, "Multi message logs are unimplemeneted");
|
|
|
|
return;
|
2018-01-06 11:41:56 -08:00
|
|
|
}
|
|
|
|
|
2018-01-04 21:45:13 -08:00
|
|
|
// Parse out log metadata
|
|
|
|
u32 line{};
|
|
|
|
std::string message, filename, function;
|
|
|
|
while (addr < end_addr) {
|
|
|
|
const Field field{static_cast<Field>(Memory::Read8(addr++))};
|
|
|
|
size_t length{Memory::Read8(addr++)};
|
|
|
|
switch (field) {
|
|
|
|
case Field::Message:
|
|
|
|
message = Memory::ReadCString(addr, length);
|
|
|
|
break;
|
|
|
|
case Field::Line:
|
|
|
|
line = Memory::Read32(addr);
|
|
|
|
break;
|
|
|
|
case Field::Filename:
|
|
|
|
filename = Memory::ReadCString(addr, length);
|
|
|
|
break;
|
|
|
|
case Field::Function:
|
|
|
|
function = Memory::ReadCString(addr, length);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
addr += length;
|
|
|
|
}
|
2017-10-18 18:41:24 -07:00
|
|
|
|
2018-01-04 21:45:13 -08:00
|
|
|
// Empty log - nothing to do here
|
2018-01-09 12:14:21 -08:00
|
|
|
if (message.empty()) {
|
2018-01-04 21:45:13 -08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Format a nicely printable string out of the log metadata
|
|
|
|
std::string output;
|
|
|
|
if (filename.size()) {
|
|
|
|
output += filename + ':';
|
|
|
|
}
|
|
|
|
if (function.size()) {
|
|
|
|
output += function + ':';
|
|
|
|
}
|
|
|
|
if (line) {
|
|
|
|
output += std::to_string(line) + ':';
|
|
|
|
}
|
|
|
|
if (output.back() == ':') {
|
|
|
|
output += ' ';
|
|
|
|
}
|
|
|
|
output += message;
|
|
|
|
|
|
|
|
LOG_DEBUG(Debug_Emulated, "%s", output.c_str());
|
2017-10-18 18:41:24 -07:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-10-14 19:18:42 -07:00
|
|
|
void InstallInterfaces(SM::ServiceManager& service_manager) {
|
|
|
|
std::make_shared<LM>()->InstallAsService(service_manager);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-10-14 19:50:04 -07:00
|
|
|
* LM::Initialize service function
|
2017-10-14 19:18:42 -07:00
|
|
|
* Inputs:
|
|
|
|
* 0: 0x00000000
|
|
|
|
* Outputs:
|
2017-10-14 22:24:22 -07:00
|
|
|
* 0: ResultCode
|
2017-10-14 19:18:42 -07:00
|
|
|
*/
|
|
|
|
void LM::Initialize(Kernel::HLERequestContext& ctx) {
|
2017-10-18 18:41:24 -07:00
|
|
|
auto client_port = std::make_shared<Logger>()->CreatePort();
|
|
|
|
auto session = client_port->Connect();
|
|
|
|
if (session.Succeeded()) {
|
|
|
|
LOG_DEBUG(Service_SM, "called, initialized logger -> session=%u",
|
|
|
|
(*session)->GetObjectId());
|
2018-01-14 18:44:20 -08:00
|
|
|
IPC::RequestBuilder rb{ctx, 2, 0, 1};
|
2017-10-18 18:41:24 -07:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
2018-01-06 22:50:55 -08:00
|
|
|
rb.PushMoveObjects(std::move(session).Unwrap());
|
2017-10-18 18:41:24 -07:00
|
|
|
registered_loggers.emplace_back(std::move(client_port));
|
|
|
|
} else {
|
|
|
|
UNIMPLEMENTED();
|
|
|
|
}
|
|
|
|
|
|
|
|
LOG_INFO(Service_SM, "called");
|
2017-10-14 19:18:42 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
LM::LM() : ServiceFramework("lm") {
|
|
|
|
static const FunctionInfo functions[] = {
|
|
|
|
{0x00000000, &LM::Initialize, "Initialize"},
|
|
|
|
};
|
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace LM
|
|
|
|
} // namespace Service
|