338 lines
9.6 KiB
C++
338 lines
9.6 KiB
C++
/**
|
|
******************************************************************************
|
|
* Xenia : Xbox 360 Emulator Research Project *
|
|
******************************************************************************
|
|
* Copyright 2013 Ben Vanik. All rights reserved. *
|
|
* Released under the BSD license - see LICENSE in the root for more details. *
|
|
******************************************************************************
|
|
*/
|
|
|
|
#include "xenia/base/logging.h"
|
|
|
|
#include <gflags/gflags.h>
|
|
|
|
#include <atomic>
|
|
#include <cinttypes>
|
|
#include <cstdarg>
|
|
#include <cstdlib>
|
|
#include <mutex>
|
|
#include <vector>
|
|
|
|
#include "xenia/base/atomic.h"
|
|
#include "xenia/base/debugging.h"
|
|
#include "xenia/base/filesystem.h"
|
|
#include "xenia/base/main.h"
|
|
#include "xenia/base/math.h"
|
|
#include "xenia/base/memory.h"
|
|
#include "xenia/base/ring_buffer.h"
|
|
#include "xenia/base/threading.h"
|
|
|
|
// For MessageBox:
|
|
// TODO(benvanik): generic API? logging_win.cc?
|
|
#if XE_PLATFORM_WIN32
|
|
#include "xenia/base/platform_win.h"
|
|
#endif // XE_PLATFORM_WIN32
|
|
|
|
DEFINE_string(
|
|
log_file, "",
|
|
"Logs are written to the given file (specify stdout for command line)");
|
|
DEFINE_bool(log_debugprint, false, "Dump the log to DebugPrint.");
|
|
DEFINE_bool(flush_log, true, "Flush log file after each log line batch.");
|
|
DEFINE_int32(
|
|
log_level, 2,
|
|
"Maximum level to be logged. (0=error, 1=warning, 2=info, 3=debug)");
|
|
|
|
namespace xe {
|
|
|
|
class Logger;
|
|
|
|
Logger* logger_ = nullptr;
|
|
thread_local std::vector<char> log_format_buffer_(64 * 1024);
|
|
|
|
class Logger {
|
|
public:
|
|
explicit Logger(const std::wstring& app_name) : running_(true) {
|
|
if (FLAGS_log_file.empty()) {
|
|
// Default to app name.
|
|
auto file_path = app_name + L".log";
|
|
xe::filesystem::CreateParentFolder(file_path);
|
|
file_ = xe::filesystem::OpenFile(file_path, "wt");
|
|
} else {
|
|
if (FLAGS_log_file == "stdout") {
|
|
file_ = stdout;
|
|
} else {
|
|
auto file_path = xe::to_wstring(FLAGS_log_file.c_str());
|
|
xe::filesystem::CreateParentFolder(file_path);
|
|
file_ = xe::filesystem::OpenFile(file_path, "wt");
|
|
}
|
|
}
|
|
|
|
write_thread_ =
|
|
xe::threading::Thread::Create({}, [this]() { WriteThread(); });
|
|
write_thread_->set_name("xe::FileLogSink Writer");
|
|
}
|
|
|
|
~Logger() {
|
|
running_ = false;
|
|
xe::threading::Wait(write_thread_.get(), true);
|
|
fflush(file_);
|
|
fclose(file_);
|
|
}
|
|
|
|
void AppendLine(uint32_t thread_id, LogLevel level, const char prefix_char,
|
|
const char* buffer, size_t buffer_length) {
|
|
if (static_cast<int32_t>(level) > FLAGS_log_level) {
|
|
// Discard this line.
|
|
return;
|
|
}
|
|
|
|
LogLine line;
|
|
line.buffer_length = buffer_length;
|
|
line.thread_id = thread_id;
|
|
line.prefix_char = prefix_char;
|
|
|
|
// First, run a check and see if we can increment write
|
|
// head without any problems. If so, cmpxchg it to reserve some space in the
|
|
// ring. If someone beats us, loop around.
|
|
//
|
|
// Once we have a reservation, write our data and then increment the write
|
|
// tail.
|
|
size_t size = sizeof(LogLine) + buffer_length;
|
|
while (true) {
|
|
// Attempt to make a reservation.
|
|
size_t write_head = write_head_;
|
|
size_t read_head = read_head_;
|
|
|
|
RingBuffer rb(buffer_, kBufferSize);
|
|
rb.set_write_offset(write_head);
|
|
rb.set_read_offset(read_head);
|
|
if (rb.write_count() < size) {
|
|
xe::threading::MaybeYield();
|
|
continue;
|
|
}
|
|
|
|
// We have enough size to make a reservation!
|
|
rb.AdvanceWrite(size);
|
|
if (xe::atomic_cas(write_head, rb.write_offset(), &write_head_)) {
|
|
// Reservation made. Write out logline.
|
|
rb.set_write_offset(write_head);
|
|
rb.Write(&line, sizeof(LogLine));
|
|
rb.Write(buffer, buffer_length);
|
|
|
|
while (!xe::atomic_cas(write_head, rb.write_offset(), &write_tail_)) {
|
|
// Done writing. End the reservation.
|
|
xe::threading::MaybeYield();
|
|
}
|
|
|
|
break;
|
|
} else {
|
|
// Someone beat us to the chase. Loop around.
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
static const size_t kBufferSize = 8 * 1024 * 1024;
|
|
|
|
struct LogLine {
|
|
size_t buffer_length;
|
|
uint32_t thread_id;
|
|
uint16_t _pad_0; // (2b) padding
|
|
uint8_t _pad_1; // (1b) padding
|
|
char prefix_char;
|
|
};
|
|
|
|
void Write(const char* buf, size_t size) {
|
|
if (file_) {
|
|
fwrite(buf, 1, size, file_);
|
|
}
|
|
|
|
if (FLAGS_log_debugprint) {
|
|
debugging::DebugPrint("%.*s", size, buf);
|
|
}
|
|
}
|
|
|
|
void WriteThread() {
|
|
RingBuffer rb(buffer_, kBufferSize);
|
|
uint32_t idle_loops = 0;
|
|
while (true) {
|
|
bool did_write = false;
|
|
rb.set_write_offset(write_tail_);
|
|
if (!running_ && rb.empty()) {
|
|
break;
|
|
}
|
|
while (!rb.empty()) {
|
|
did_write = true;
|
|
|
|
// Read line header and write out the line prefix.
|
|
LogLine line;
|
|
rb.Read(&line, sizeof(line));
|
|
char prefix[] = {
|
|
line.prefix_char,
|
|
'>',
|
|
' ',
|
|
'0', // Thread ID gets placed here (8 chars).
|
|
'0',
|
|
'0',
|
|
'0',
|
|
'0',
|
|
'0',
|
|
'0',
|
|
'0',
|
|
' ',
|
|
0,
|
|
};
|
|
std::snprintf(prefix + 3, sizeof(prefix) - 3, "%08" PRIX32 " ",
|
|
line.thread_id);
|
|
Write(prefix, sizeof(prefix) - 1);
|
|
if (line.buffer_length) {
|
|
// Get access to the line data - which may be split in the ring buffer
|
|
// - and write it out in parts.
|
|
auto line_range = rb.BeginRead(line.buffer_length);
|
|
Write(reinterpret_cast<const char*>(line_range.first),
|
|
line_range.first_length);
|
|
if (line_range.second_length) {
|
|
Write(reinterpret_cast<const char*>(line_range.second),
|
|
line_range.second_length);
|
|
}
|
|
// Always ensure there is a newline.
|
|
char last_char = line_range.second
|
|
? line_range.second[line_range.second_length - 1]
|
|
: line_range.first[line_range.first_length - 1];
|
|
if (last_char != '\n') {
|
|
const char suffix[1] = {'\n'};
|
|
Write(suffix, 1);
|
|
}
|
|
rb.EndRead(std::move(line_range));
|
|
} else {
|
|
const char suffix[1] = {'\n'};
|
|
Write(suffix, 1);
|
|
}
|
|
|
|
rb.set_write_offset(write_tail_);
|
|
read_head_ = rb.read_offset();
|
|
}
|
|
if (did_write) {
|
|
if (FLAGS_flush_log) {
|
|
fflush(file_);
|
|
}
|
|
|
|
idle_loops = 0;
|
|
} else {
|
|
if (idle_loops > 1000) {
|
|
// Introduce a waiting period.
|
|
xe::threading::Sleep(std::chrono::milliseconds(50));
|
|
}
|
|
|
|
idle_loops++;
|
|
}
|
|
}
|
|
}
|
|
|
|
volatile size_t write_tail_ = 0;
|
|
size_t write_head_ = 0;
|
|
size_t read_head_ = 0;
|
|
uint8_t buffer_[kBufferSize];
|
|
FILE* file_ = nullptr;
|
|
|
|
std::atomic<bool> running_;
|
|
std::unique_ptr<xe::threading::Thread> write_thread_;
|
|
};
|
|
|
|
void InitializeLogging(const std::wstring& app_name) {
|
|
auto mem = memory::AlignedAlloc<Logger>(0x10);
|
|
logger_ = new (mem) Logger(app_name);
|
|
}
|
|
|
|
void ShutdownLogging() {
|
|
Logger* logger = logger_;
|
|
logger_ = nullptr;
|
|
|
|
logger->~Logger();
|
|
memory::AlignedFree(logger);
|
|
}
|
|
|
|
void LogLineFormat(LogLevel log_level, const char prefix_char, const char* fmt,
|
|
...) {
|
|
if (!logger_) {
|
|
return;
|
|
}
|
|
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
int chars_written = vsnprintf(log_format_buffer_.data(),
|
|
log_format_buffer_.capacity(), fmt, args);
|
|
va_end(args);
|
|
if (chars_written >= 0 && chars_written < log_format_buffer_.capacity()) {
|
|
logger_->AppendLine(xe::threading::current_thread_id(), log_level,
|
|
prefix_char, log_format_buffer_.data(), chars_written);
|
|
} else if (chars_written >= 0) {
|
|
logger_->AppendLine(xe::threading::current_thread_id(), log_level,
|
|
prefix_char, fmt, std::strlen(fmt));
|
|
}
|
|
}
|
|
|
|
void LogLineVarargs(LogLevel log_level, const char prefix_char, const char* fmt,
|
|
va_list args) {
|
|
if (!logger_) {
|
|
return;
|
|
}
|
|
|
|
int chars_written = vsnprintf(log_format_buffer_.data(),
|
|
log_format_buffer_.capacity(), fmt, args);
|
|
if (chars_written < 0) {
|
|
return;
|
|
}
|
|
|
|
auto size =
|
|
std::min(size_t(chars_written), log_format_buffer_.capacity() - 1);
|
|
logger_->AppendLine(xe::threading::current_thread_id(), log_level,
|
|
prefix_char, log_format_buffer_.data(), size);
|
|
}
|
|
|
|
void LogLine(LogLevel log_level, const char prefix_char, const char* str,
|
|
size_t str_length) {
|
|
if (!logger_) {
|
|
return;
|
|
}
|
|
|
|
logger_->AppendLine(
|
|
xe::threading::current_thread_id(), log_level, prefix_char, str,
|
|
str_length == std::string::npos ? std::strlen(str) : str_length);
|
|
}
|
|
|
|
void LogLine(LogLevel log_level, const char prefix_char,
|
|
const std::string& str) {
|
|
if (!logger_) {
|
|
return;
|
|
}
|
|
|
|
logger_->AppendLine(xe::threading::current_thread_id(), log_level,
|
|
prefix_char, str.c_str(), str.length());
|
|
}
|
|
|
|
void FatalError(const char* fmt, ...) {
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
LogLineVarargs(LogLevel::Error, 'X', fmt, args);
|
|
va_end(args);
|
|
|
|
#if XE_PLATFORM_WIN32
|
|
if (!xe::has_console_attached()) {
|
|
va_start(args, fmt);
|
|
vsnprintf(log_format_buffer_.data(), log_format_buffer_.capacity(), fmt,
|
|
args);
|
|
va_end(args);
|
|
MessageBoxA(NULL, log_format_buffer_.data(), "Xenia Error",
|
|
MB_OK | MB_ICONERROR | MB_APPLMODAL | MB_SETFOREGROUND);
|
|
}
|
|
#endif // WIN32
|
|
|
|
exit(1);
|
|
}
|
|
|
|
void FatalError(const std::string& str) { FatalError(str.c_str()); }
|
|
|
|
} // namespace xe
|