654 lines
23 KiB
C++
654 lines
23 KiB
C++
#if defined(_WIN32)
|
||
|
||
#include "windows_include.h"
|
||
|
||
#include <algorithm>
|
||
#include <cctype>
|
||
#include <cstdint>
|
||
#include <cstdlib>
|
||
#include <cwchar>
|
||
#include <filesystem>
|
||
#include <iomanip>
|
||
#include <iostream>
|
||
#include <memory>
|
||
#include <sstream>
|
||
#include <string>
|
||
#include <system_error>
|
||
#include <thread>
|
||
#include <type_traits>
|
||
#include <vector>
|
||
|
||
#include <dbghelp.h>
|
||
#include <objbase.h>
|
||
#include <oleauto.h>
|
||
#include <psapi.h>
|
||
#include <wbemidl.h>
|
||
|
||
|
||
#include "../Base/global_include.h"
|
||
#include "../system/export.h"
|
||
#include "Core/Base/JSON.h"
|
||
|
||
namespace Psc {
|
||
namespace {
|
||
std::wstring utf8_to_wide_impl(const std::string& input) {
|
||
if (input.empty()) {
|
||
return L"";
|
||
}
|
||
|
||
const int size = MultiByteToWideChar(CP_UTF8, 0, input.data(), static_cast<int>(input.size()), nullptr, 0);
|
||
if (size <= 0) {
|
||
return L"";
|
||
}
|
||
|
||
std::wstring result(static_cast<size_t>(size), L'\0');
|
||
MultiByteToWideChar(CP_UTF8, 0, input.data(), static_cast<int>(input.size()), result.data(), size);
|
||
return result;
|
||
}
|
||
|
||
std::string wide_to_utf8_impl(const wchar_t* input, int input_len = -1) {
|
||
if (!input) {
|
||
return "";
|
||
}
|
||
|
||
const int size = WideCharToMultiByte(CP_UTF8, 0, input, input_len, nullptr, 0, nullptr, nullptr);
|
||
if (size <= 0) {
|
||
return "";
|
||
}
|
||
|
||
std::string result(static_cast<size_t>(size), '\0');
|
||
WideCharToMultiByte(CP_UTF8, 0, input, input_len, result.data(), size, nullptr, nullptr);
|
||
if (input_len == -1 && !result.empty() && result.back() == '\0') {
|
||
result.pop_back();
|
||
}
|
||
return result;
|
||
}
|
||
|
||
std::string wide_to_utf8_impl(const std::wstring& input) {
|
||
return wide_to_utf8_impl(input.c_str(), static_cast<int>(input.size()));
|
||
}
|
||
|
||
std::string codepage_to_utf8(const std::string& input, UINT codepage) {
|
||
if (input.empty()) {
|
||
return "";
|
||
}
|
||
|
||
const int wide_len = MultiByteToWideChar(codepage, 0, input.data(), static_cast<int>(input.size()), nullptr, 0);
|
||
if (wide_len <= 0) {
|
||
return "";
|
||
}
|
||
|
||
std::wstring wide(static_cast<size_t>(wide_len), L'\0');
|
||
MultiByteToWideChar(codepage, 0, input.data(), static_cast<int>(input.size()), wide.data(), wide_len);
|
||
return wide_to_utf8_impl(wide);
|
||
}
|
||
|
||
std::string utf8_to_codepage(const std::string& input, UINT codepage) {
|
||
if (input.empty()) {
|
||
return "";
|
||
}
|
||
|
||
const std::wstring wide = utf8_to_wide_impl(input);
|
||
if (wide.empty()) {
|
||
return "";
|
||
}
|
||
|
||
const int len = WideCharToMultiByte(codepage, 0, wide.data(), static_cast<int>(wide.size()), nullptr, 0, nullptr, nullptr);
|
||
if (len <= 0) {
|
||
return "";
|
||
}
|
||
|
||
std::string result(static_cast<size_t>(len), '\0');
|
||
WideCharToMultiByte(codepage, 0, wide.data(), static_cast<int>(wide.size()), result.data(), len, nullptr, nullptr);
|
||
return result;
|
||
}
|
||
|
||
std::wstring read_env_w(const wchar_t* name) {
|
||
DWORD required = GetEnvironmentVariableW(name, nullptr, 0);
|
||
if (required == 0) {
|
||
return L"";
|
||
}
|
||
|
||
std::wstring result(required, L'\0');
|
||
DWORD written = GetEnvironmentVariableW(name, result.data(), required);
|
||
if (written == 0) {
|
||
return L"";
|
||
}
|
||
|
||
result.resize(written);
|
||
return result;
|
||
}
|
||
|
||
HANDLE thread_to_win32_handle(std::thread* thread) noexcept {
|
||
if (!thread) {
|
||
return nullptr;
|
||
}
|
||
|
||
using Native = std::thread::native_handle_type;
|
||
if constexpr (std::is_pointer<Native>::value) {
|
||
return reinterpret_cast<HANDLE>(thread->native_handle());
|
||
} else if constexpr (std::is_integral<Native>::value) {
|
||
return reinterpret_cast<HANDLE>(thread->native_handle());
|
||
} else {
|
||
// MinGW 的 libstdc++ 在某些配置下使用 winpthreads，native_handle_type 不是 Win32 HANDLE。
|
||
return nullptr;
|
||
}
|
||
}
|
||
|
||
struct Bstr_Guard {
|
||
explicit Bstr_Guard(const wchar_t* value) : value(SysAllocString(value)) {}
|
||
~Bstr_Guard() { if (value) SysFreeString(value); }
|
||
Bstr_Guard(const Bstr_Guard&) = delete;
|
||
Bstr_Guard& operator=(const Bstr_Guard&) = delete;
|
||
BSTR value{};
|
||
};
|
||
|
||
template <typename T>
|
||
void release_com(T*& ptr) noexcept {
|
||
if (ptr) {
|
||
ptr->Release();
|
||
ptr = nullptr;
|
||
}
|
||
}
|
||
|
||
std::string fallback_stack_trace_without_dbghelp(void* const* stack, USHORT frames) {
|
||
std::ostringstream oss;
|
||
oss << "Stack trace addresses only; DbgHelp unavailable.\n";
|
||
for (USHORT i = 0; i < frames; ++i) {
|
||
oss << "Frame " << std::setw(2) << i << ": " << stack[i] << '\n';
|
||
}
|
||
return oss.str();
|
||
}
|
||
}
|
||
|
||
std::string get_stack_trace() {
|
||
constexpr int max_frames = 64;
|
||
void* stack[max_frames]{};
|
||
const USHORT frames = CaptureStackBackTrace(0, max_frames, stack, nullptr);
|
||
|
||
HMODULE dbghelp = LoadLibraryW(L"DbgHelp.dll");
|
||
if (!dbghelp) {
|
||
return fallback_stack_trace_without_dbghelp(stack, frames);
|
||
}
|
||
|
||
using SymInitializeT = BOOL(WINAPI*)(HANDLE, PCSTR, BOOL);
|
||
using SymSetOptionsT = DWORD(WINAPI*)(DWORD);
|
||
using SymFromAddrT = BOOL(WINAPI*)(HANDLE, DWORD64, PDWORD64, PSYMBOL_INFO);
|
||
using SymGetLineFromAddr64T = BOOL(WINAPI*)(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINE64);
|
||
using SymCleanupT = BOOL(WINAPI*)(HANDLE);
|
||
|
||
auto pSymInitialize = reinterpret_cast<SymInitializeT>(GetProcAddress(dbghelp, "SymInitialize"));
|
||
auto pSymSetOptions = reinterpret_cast<SymSetOptionsT>(GetProcAddress(dbghelp, "SymSetOptions"));
|
||
auto pSymFromAddr = reinterpret_cast<SymFromAddrT>(GetProcAddress(dbghelp, "SymFromAddr"));
|
||
auto pSymGetLineFromAddr64 = reinterpret_cast<SymGetLineFromAddr64T>(GetProcAddress(dbghelp, "SymGetLineFromAddr64"));
|
||
auto pSymCleanup = reinterpret_cast<SymCleanupT>(GetProcAddress(dbghelp, "SymCleanup"));
|
||
|
||
if (!pSymInitialize || !pSymSetOptions || !pSymFromAddr || !pSymGetLineFromAddr64) {
|
||
FreeLibrary(dbghelp);
|
||
return fallback_stack_trace_without_dbghelp(stack, frames);
|
||
}
|
||
|
||
HANDLE process = GetCurrentProcess();
|
||
std::ostringstream oss;
|
||
|
||
if (!pSymInitialize(process, nullptr, TRUE)) {
|
||
FreeLibrary(dbghelp);
|
||
return fallback_stack_trace_without_dbghelp(stack, frames);
|
||
}
|
||
|
||
pSymSetOptions(SYMOPT_LOAD_LINES | SYMOPT_UNDNAME);
|
||
|
||
constexpr DWORD max_name_len = MAX_SYM_NAME;
|
||
std::vector<unsigned char> symbol_buffer(sizeof(SYMBOL_INFO) + max_name_len * sizeof(char));
|
||
auto* symbol = reinterpret_cast<SYMBOL_INFO*>(symbol_buffer.data());
|
||
symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
|
||
symbol->MaxNameLen = max_name_len;
|
||
|
||
for (USHORT i = 0; i < frames; ++i) {
|
||
DWORD64 address = reinterpret_cast<DWORD64>(stack[i]);
|
||
DWORD64 displacement64 = 0;
|
||
|
||
oss << "Frame " << std::right << std::setw(2) << i << ": ";
|
||
|
||
if (pSymFromAddr(process, address, &displacement64, symbol)) {
|
||
oss << std::left << std::setw(30) << symbol->Name << " ";
|
||
} else {
|
||
oss << std::left << std::setw(30) << "<unknown>" << " ";
|
||
}
|
||
|
||
IMAGEHLP_LINE64 line{};
|
||
line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
|
||
DWORD displacement = 0;
|
||
if (pSymGetLineFromAddr64(process, address, &displacement, &line)) {
|
||
oss << line.FileName << ':' << line.LineNumber << " at 0x" << std::hex << address << std::dec << '\n';
|
||
} else {
|
||
oss << "at 0x" << std::hex << address << std::dec << '\n';
|
||
}
|
||
}
|
||
|
||
if (pSymCleanup) {
|
||
pSymCleanup(process);
|
||
}
|
||
FreeLibrary(dbghelp);
|
||
return oss.str();
|
||
}
|
||
|
||
void set_current_thread_name(const std::string& name) {
|
||
const std::wstring wname = utf8_to_wide_impl(name);
|
||
if (wname.empty()) {
|
||
return;
|
||
}
|
||
|
||
using SetThreadDescriptionT = HRESULT(WINAPI*)(HANDLE, PCWSTR);
|
||
HMODULE kernel32 = GetModuleHandleW(L"Kernel32.dll");
|
||
auto pSetThreadDescription = kernel32
|
||
? reinterpret_cast<SetThreadDescriptionT>(GetProcAddress(kernel32, "SetThreadDescription"))
|
||
: nullptr;
|
||
|
||
if (pSetThreadDescription) {
|
||
(void)pSetThreadDescription(GetCurrentThread(), wname.c_str());
|
||
}
|
||
}
|
||
|
||
void set_console_utf8() {
|
||
(void)SetConsoleOutputCP(CP_UTF8);
|
||
(void)SetConsoleCP(CP_UTF8);
|
||
}
|
||
|
||
PSC_DEFINE_TRIPLE_API_FROM_BOOL(void*, load_library, PSC_LOAD_LIBRARY_PARAMS)
|
||
|
||
bool load_library_ec(const std::string& library_path, void*& out, std::error_code& ec) noexcept {
|
||
out = nullptr;
|
||
ec.clear();
|
||
|
||
if (library_path.empty()) {
|
||
ec = std::make_error_code(std::errc::invalid_argument);
|
||
return false;
|
||
}
|
||
|
||
const std::wstring wpath = utf8_to_wide_impl(library_path);
|
||
HMODULE h = LoadLibraryW(wpath.c_str());
|
||
if (!h) {
|
||
ec = std::error_code(static_cast<int>(GetLastError()), std::system_category());
|
||
std::cerr << "加载库失败:【" << library_path << "】 "
|
||
<< ec.message() << " (code=" << ec.value() << ")\n";
|
||
return false;
|
||
}
|
||
|
||
out = reinterpret_cast<void*>(h);
|
||
return true;
|
||
}
|
||
|
||
void* load_library_fail_fast(const std::string& library_path) {
|
||
auto ret = try_load_library(library_path);
|
||
if (!ret) {
|
||
Psc::fail_fast();
|
||
}
|
||
return ret.value();
|
||
}
|
||
|
||
void free_library(void* library) {
|
||
if (library) {
|
||
FreeLibrary(reinterpret_cast<HMODULE>(library));
|
||
}
|
||
}
|
||
|
||
PSC_DEFINE_TRIPLE_API_FROM_BOOL(void*, load_function, PSC_LOAD_FUNCTION_PARAMS)
|
||
|
||
bool load_function_ec(void* library, const std::string& function_name, void*& out, std::error_code& ec) noexcept {
|
||
out = nullptr;
|
||
ec.clear();
|
||
|
||
if (!library) {
|
||
ec = std::make_error_code(std::errc::invalid_argument);
|
||
std::cerr << "load_function: " << function_name << " but library == nullptr\n";
|
||
return false;
|
||
}
|
||
|
||
FARPROC p = GetProcAddress(reinterpret_cast<HMODULE>(library), function_name.c_str());
|
||
if (!p) {
|
||
ec = std::error_code(static_cast<int>(GetLastError()), std::system_category());
|
||
std::cerr << "Failed to get function pointer for: " << function_name
|
||
<< " : " << ec.message() << " (code=" << ec.value() << ")\n";
|
||
return false;
|
||
}
|
||
|
||
out = reinterpret_cast<void*>(p);
|
||
return true;
|
||
}
|
||
|
||
void* load_function_fail_fast(void* library, const std::string& function_name) {
|
||
auto ret = try_load_function(library, function_name);
|
||
if (!ret) {
|
||
Psc::fail_fast();
|
||
}
|
||
return ret.value();
|
||
}
|
||
|
||
std::string get_computer_serial_number() {
|
||
HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
|
||
const bool need_uninit = SUCCEEDED(hr);
|
||
if (FAILED(hr) && hr != RPC_E_CHANGED_MODE) {
|
||
return "";
|
||
}
|
||
|
||
hr = CoInitializeSecurity(nullptr, -1, nullptr, nullptr,
|
||
RPC_C_AUTHN_LEVEL_DEFAULT,
|
||
RPC_C_IMP_LEVEL_IMPERSONATE,
|
||
nullptr, EOAC_NONE, nullptr);
|
||
if (FAILED(hr) && hr != RPC_E_TOO_LATE) {
|
||
if (need_uninit) {
|
||
CoUninitialize();
|
||
}
|
||
return "";
|
||
}
|
||
|
||
IWbemLocator* locator = nullptr;
|
||
IWbemServices* services = nullptr;
|
||
IEnumWbemClassObject* enumerator = nullptr;
|
||
IWbemClassObject* object = nullptr;
|
||
std::string result;
|
||
|
||
hr = CoCreateInstance(CLSID_WbemLocator, nullptr, CLSCTX_INPROC_SERVER,
|
||
IID_IWbemLocator, reinterpret_cast<void**>(&locator));
|
||
if (FAILED(hr) || !locator) {
|
||
if (need_uninit) CoUninitialize();
|
||
return "";
|
||
}
|
||
|
||
Bstr_Guard ns(L"ROOT\\CIMV2");
|
||
hr = locator->ConnectServer(ns.value, nullptr, nullptr, nullptr, 0, nullptr, nullptr, &services);
|
||
if (SUCCEEDED(hr) && services) {
|
||
hr = CoSetProxyBlanket(services,
|
||
RPC_C_AUTHN_WINNT,
|
||
RPC_C_AUTHZ_NONE,
|
||
nullptr,
|
||
RPC_C_AUTHN_LEVEL_CALL,
|
||
RPC_C_IMP_LEVEL_IMPERSONATE,
|
||
nullptr,
|
||
EOAC_NONE);
|
||
}
|
||
|
||
if (SUCCEEDED(hr) && services) {
|
||
Bstr_Guard lang(L"WQL");
|
||
Bstr_Guard query(L"SELECT SerialNumber FROM Win32_BIOS");
|
||
hr = services->ExecQuery(lang.value, query.value,
|
||
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
|
||
nullptr, &enumerator);
|
||
}
|
||
|
||
if (SUCCEEDED(hr) && enumerator) {
|
||
ULONG returned = 0;
|
||
hr = enumerator->Next(WBEM_INFINITE, 1, &object, &returned);
|
||
if (SUCCEEDED(hr) && returned > 0 && object) {
|
||
VARIANT vtSerial;
|
||
VariantInit(&vtSerial);
|
||
hr = object->Get(L"SerialNumber", 0, &vtSerial, nullptr, nullptr);
|
||
if (SUCCEEDED(hr) && vtSerial.vt == VT_BSTR && vtSerial.bstrVal) {
|
||
result = wide_to_utf8_impl(vtSerial.bstrVal);
|
||
}
|
||
VariantClear(&vtSerial);
|
||
}
|
||
}
|
||
|
||
release_com(object);
|
||
release_com(enumerator);
|
||
release_com(services);
|
||
release_com(locator);
|
||
if (need_uninit) {
|
||
CoUninitialize();
|
||
}
|
||
return result;
|
||
}
|
||
|
||
std::string error_code_to_string(DWORD error_code) {
|
||
wchar_t* message = nullptr;
|
||
DWORD size = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
||
FORMAT_MESSAGE_FROM_SYSTEM |
|
||
FORMAT_MESSAGE_IGNORE_INSERTS,
|
||
nullptr,
|
||
error_code,
|
||
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
||
reinterpret_cast<LPWSTR>(&message),
|
||
0,
|
||
nullptr);
|
||
|
||
std::string result = "错误码：" + std::to_string(error_code) + ": ";
|
||
if (size > 0 && message) {
|
||
result += wide_to_utf8_impl(message, static_cast<int>(size));
|
||
LocalFree(message);
|
||
} else {
|
||
result += "获取错误信息失败";
|
||
}
|
||
return result;
|
||
}
|
||
|
||
std::string get_error_message() {
|
||
return error_code_to_string(GetLastError());
|
||
}
|
||
|
||
std::string get_error_message(ERROR_CODE_TYPE code) {
|
||
return error_code_to_string(static_cast<DWORD>(code));
|
||
}
|
||
|
||
ERROR_CODE_TYPE get_error_code() {
|
||
return static_cast<ERROR_CODE_TYPE>(GetLastError());
|
||
}
|
||
|
||
void set_error_code(ERROR_CODE_TYPE code) {
|
||
SetLastError(static_cast<DWORD>(code));
|
||
}
|
||
|
||
std::string to_upper_case(const std::string& input) {
|
||
std::string result = input;
|
||
for (char& ch : result) {
|
||
ch = static_cast<char>(std::toupper(static_cast<unsigned char>(ch)));
|
||
}
|
||
return result;
|
||
}
|
||
|
||
std::string get_home_dir() {
|
||
std::wstring home = read_env_w(L"USERPROFILE");
|
||
if (home.empty()) {
|
||
std::wstring drive = read_env_w(L"HOMEDRIVE");
|
||
std::wstring path = read_env_w(L"HOMEPATH");
|
||
home = drive + path;
|
||
}
|
||
std::string result = wide_to_utf8_impl(home);
|
||
std::replace(result.begin(), result.end(), '\\', '/');
|
||
return result;
|
||
}
|
||
|
||
std::string get_exe_path() {
|
||
std::wstring buffer(MAX_PATH, L'\0');
|
||
|
||
for (;;) {
|
||
DWORD len = GetModuleFileNameW(nullptr, buffer.data(), static_cast<DWORD>(buffer.size()));
|
||
if (len == 0) {
|
||
return "";
|
||
}
|
||
|
||
if (len < buffer.size() - 1) {
|
||
buffer.resize(len);
|
||
break;
|
||
}
|
||
|
||
buffer.resize(buffer.size() * 2);
|
||
if (buffer.size() > 32768) {
|
||
return "";
|
||
}
|
||
}
|
||
|
||
std::string result = wide_to_utf8_impl(buffer);
|
||
std::replace(result.begin(), result.end(), '\\', '/');
|
||
return result;
|
||
}
|
||
|
||
std::string utf8_to_gbk(const std::string& utf8Str) {
|
||
return utf8_to_codepage(utf8Str, CP_ACP);
|
||
}
|
||
|
||
std::string gbk_to_utf8(const std::string& gbkStr) {
|
||
return codepage_to_utf8(gbkStr, CP_ACP);
|
||
}
|
||
|
||
bool set_thread_priority(std::thread* thread, int priority, bool realtime) {
|
||
HANDLE hThread = thread_to_win32_handle(thread);
|
||
if (!hThread) {
|
||
return false;
|
||
}
|
||
return set_thread_priority(reinterpret_cast<void*>(hThread), priority, realtime);
|
||
}
|
||
|
||
bool set_thread_priority(void* thread_ptr, int priority, bool realtime) {
|
||
HANDLE hThread = static_cast<HANDLE>(thread_ptr);
|
||
if (!hThread) {
|
||
return false;
|
||
}
|
||
|
||
if (realtime) {
|
||
if (!SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS)) {
|
||
return false;
|
||
}
|
||
return SetThreadPriority(hThread, THREAD_PRIORITY_TIME_CRITICAL) != 0;
|
||
}
|
||
|
||
if (priority < THREAD_PRIORITY_IDLE) {
|
||
priority = THREAD_PRIORITY_IDLE;
|
||
}
|
||
if (priority > THREAD_PRIORITY_TIME_CRITICAL) {
|
||
priority = THREAD_PRIORITY_TIME_CRITICAL;
|
||
}
|
||
|
||
return SetThreadPriority(hThread, priority) != 0;
|
||
}
|
||
|
||
bool set_thread_affinity(void* thread_ptr, unsigned cpu_index) {
|
||
HANDLE hThread = static_cast<HANDLE>(thread_ptr);
|
||
if (!hThread) {
|
||
return false;
|
||
}
|
||
|
||
const unsigned max_bits = sizeof(DWORD_PTR) * 8;
|
||
if (cpu_index >= max_bits) {
|
||
return false;
|
||
}
|
||
|
||
DWORD_PTR mask = (static_cast<DWORD_PTR>(1) << cpu_index);
|
||
return SetThreadAffinityMask(hThread, mask) != 0;
|
||
}
|
||
|
||
bool set_thread_affinity(std::thread* thread, unsigned cpu_index) {
|
||
HANDLE hThread = thread_to_win32_handle(thread);
|
||
if (!hThread) {
|
||
return false;
|
||
}
|
||
return set_thread_affinity(reinterpret_cast<void*>(hThread), cpu_index);
|
||
}
|
||
|
||
size_t get_system_memory() {
|
||
MEMORYSTATUSEX memStatus{};
|
||
memStatus.dwLength = sizeof(MEMORYSTATUSEX);
|
||
if (GlobalMemoryStatusEx(&memStatus)) {
|
||
return static_cast<size_t>(memStatus.ullTotalPhys);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
size_t get_process_memory() {
|
||
PROCESS_MEMORY_COUNTERS memCounter{};
|
||
if (GetProcessMemoryInfo(GetCurrentProcess(), &memCounter, sizeof(memCounter))) {
|
||
return static_cast<size_t>(memCounter.WorkingSetSize);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
std::string get_memory_info() {
|
||
MEMORYSTATUSEX status{};
|
||
status.dwLength = sizeof(status);
|
||
if (!GlobalMemoryStatusEx(&status)) {
|
||
return "Failed to get memory status";
|
||
}
|
||
|
||
auto ret = JSON::object();
|
||
ret.append({"Total physical memory (MB)", status.ullTotalPhys / (1024 * 1024)});
|
||
ret.append({"Available physical memory (MB)", status.ullAvailPhys / (1024 * 1024)});
|
||
ret.append({"Total virtual memory (MB)", status.ullTotalVirtual / (1024 * 1024)});
|
||
ret.append({"Available virtual memory (MB)", status.ullAvailVirtual / (1024 * 1024)});
|
||
ret.append({"Total page file (MB)", status.ullTotalPageFile / (1024 * 1024)});
|
||
ret.append({"Available page file (MB)", status.ullAvailPageFile / (1024 * 1024)});
|
||
return ret.to_json_string();
|
||
}
|
||
|
||
int GenerateMiniDump(PEXCEPTION_POINTERS pExceptionPointers) {
|
||
using MiniDumpWriteDumpT = BOOL(WINAPI*)(HANDLE,
|
||
DWORD,
|
||
HANDLE,
|
||
MINIDUMP_TYPE,
|
||
PMINIDUMP_EXCEPTION_INFORMATION,
|
||
PMINIDUMP_USER_STREAM_INFORMATION,
|
||
PMINIDUMP_CALLBACK_INFORMATION);
|
||
|
||
HMODULE hDbgHelp = LoadLibraryW(L"DbgHelp.dll");
|
||
if (!hDbgHelp) {
|
||
return EXCEPTION_CONTINUE_EXECUTION;
|
||
}
|
||
|
||
auto pfnMiniDumpWriteDump = reinterpret_cast<MiniDumpWriteDumpT>(GetProcAddress(hDbgHelp, "MiniDumpWriteDump"));
|
||
if (!pfnMiniDumpWriteDump) {
|
||
FreeLibrary(hDbgHelp);
|
||
return EXCEPTION_CONTINUE_EXECUTION;
|
||
}
|
||
|
||
wchar_t fileName[MAX_PATH]{};
|
||
SYSTEMTIME localTime{};
|
||
GetLocalTime(&localTime);
|
||
std::swprintf(fileName, MAX_PATH, L"DumpDemo_v1.0-%04u%02u%02u-%02u%02u%02u.dmp",
|
||
localTime.wYear,
|
||
localTime.wMonth,
|
||
localTime.wDay,
|
||
localTime.wHour,
|
||
localTime.wMinute,
|
||
localTime.wSecond);
|
||
|
||
HANDLE hDumpFile = CreateFileW(fileName,
|
||
GENERIC_READ | GENERIC_WRITE,
|
||
FILE_SHARE_WRITE | FILE_SHARE_READ,
|
||
nullptr,
|
||
CREATE_ALWAYS,
|
||
FILE_ATTRIBUTE_NORMAL,
|
||
nullptr);
|
||
if (hDumpFile == INVALID_HANDLE_VALUE) {
|
||
FreeLibrary(hDbgHelp);
|
||
return EXCEPTION_CONTINUE_EXECUTION;
|
||
}
|
||
|
||
MINIDUMP_EXCEPTION_INFORMATION expParam{};
|
||
expParam.ThreadId = GetCurrentThreadId();
|
||
expParam.ExceptionPointers = pExceptionPointers;
|
||
expParam.ClientPointers = FALSE;
|
||
|
||
pfnMiniDumpWriteDump(GetCurrentProcess(),
|
||
GetCurrentProcessId(),
|
||
hDumpFile,
|
||
MiniDumpWithDataSegs,
|
||
pExceptionPointers ? &expParam : nullptr,
|
||
nullptr,
|
||
nullptr);
|
||
|
||
CloseHandle(hDumpFile);
|
||
FreeLibrary(hDbgHelp);
|
||
return EXCEPTION_EXECUTE_HANDLER;
|
||
}
|
||
|
||
LONG WINAPI ExceptionFilter(LPEXCEPTION_POINTERS lpExceptionInfo) {
|
||
if (IsDebuggerPresent()) {
|
||
return EXCEPTION_CONTINUE_SEARCH;
|
||
}
|
||
return GenerateMiniDump(lpExceptionInfo);
|
||
}
|
||
|
||
} // namespace Psc
|
||
|
||
#endif // defined(_WIN32)
|