438 lines
13 KiB
C++
438 lines
13 KiB
C++
#if defined(__linux__)
|
|
|
|
#include "export.h"
|
|
|
|
#include <algorithm>
|
|
#include <cerrno>
|
|
#include <cctype>
|
|
#include <clocale>
|
|
#include <csignal>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <dlfcn.h>
|
|
#include <execinfo.h>
|
|
#include <fcntl.h>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <iostream>
|
|
#include <limits.h>
|
|
#include <map>
|
|
#include <pwd.h>
|
|
#include <regex>
|
|
#include <sched.h>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <sys/prctl.h>
|
|
#include <sys/resource.h>
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <thread>
|
|
#include <unistd.h>
|
|
#include <vector>
|
|
|
|
#if __has_include("Core/JSON.h")
|
|
#include "Core/JSON.h"
|
|
#elif __has_include("../Base/JSON.h")
|
|
#include "../Base/JSON.h"
|
|
#endif
|
|
|
|
namespace Psc {
|
|
namespace {
|
|
std::string trim_copy(std::string value) {
|
|
auto not_space = [](unsigned char ch) { return !std::isspace(ch); };
|
|
value.erase(value.begin(), std::find_if(value.begin(), value.end(), not_space));
|
|
value.erase(std::find_if(value.rbegin(), value.rend(), not_space).base(), value.end());
|
|
return value;
|
|
}
|
|
|
|
std::string read_first_line(const std::string& file_name) {
|
|
std::ifstream in(file_name);
|
|
std::string line;
|
|
if (std::getline(in, line)) {
|
|
return trim_copy(line);
|
|
}
|
|
return "";
|
|
}
|
|
|
|
std::string execute_command_single(const char* cmd) {
|
|
if (!cmd || !*cmd) {
|
|
return "";
|
|
}
|
|
|
|
int pipefd[2]{};
|
|
if (pipe(pipefd) != 0) {
|
|
return "";
|
|
}
|
|
|
|
pid_t pid = fork();
|
|
if (pid < 0) {
|
|
close(pipefd[0]);
|
|
close(pipefd[1]);
|
|
return "";
|
|
}
|
|
|
|
if (pid == 0) {
|
|
close(pipefd[0]);
|
|
dup2(pipefd[1], STDOUT_FILENO);
|
|
close(pipefd[1]);
|
|
setsid();
|
|
execl("/bin/sh", "sh", "-c", cmd, static_cast<char*>(nullptr));
|
|
_exit(127);
|
|
}
|
|
|
|
close(pipefd[1]);
|
|
|
|
std::string out;
|
|
char buf[1024];
|
|
ssize_t n = 0;
|
|
while ((n = read(pipefd[0], buf, sizeof(buf))) > 0) {
|
|
out.append(buf, static_cast<size_t>(n));
|
|
}
|
|
close(pipefd[0]);
|
|
waitpid(pid, nullptr, 0);
|
|
return out;
|
|
}
|
|
|
|
size_t read_proc_status_kb(const char* key) {
|
|
std::ifstream status("/proc/self/status");
|
|
std::string line;
|
|
while (std::getline(status, line)) {
|
|
if (line.rfind(key, 0) == 0) {
|
|
size_t value_kb = 0;
|
|
if (std::sscanf(line.c_str(), "%*s %zu kB", &value_kb) == 1) {
|
|
return value_kb;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
std::string extract_address(const std::string& input) {
|
|
const std::regex address_regex(R"(\[([0-9a-fA-Fx]+)\])");
|
|
std::smatch match;
|
|
if (std::regex_search(input, match, address_regex)) {
|
|
return match[1].str();
|
|
}
|
|
return "";
|
|
}
|
|
|
|
std::string execute_command(const std::string& cmd) {
|
|
FILE* fp = popen(cmd.c_str(), "r");
|
|
if (!fp) {
|
|
return "";
|
|
}
|
|
|
|
std::string result;
|
|
char buffer[1024];
|
|
while (fgets(buffer, sizeof(buffer), fp) != nullptr) {
|
|
result.append(buffer);
|
|
}
|
|
pclose(fp);
|
|
return result;
|
|
}
|
|
|
|
std::string get_tool(const std::string& name) {
|
|
std::string ret = name;
|
|
const std::string exe_dir = get_exe_dir();
|
|
const std::string ret_1 = exe_dir + "/" + name;
|
|
|
|
std::filesystem::path path = std::filesystem::u8path(exe_dir);
|
|
const auto parent = path.parent_path();
|
|
const std::string parent_path = path_to_utf8(parent);
|
|
const std::string ret_2 = parent_path + "/lib/" + name;
|
|
|
|
if (std::filesystem::exists(ret_1)) {
|
|
ret = ret_1;
|
|
} else if (std::filesystem::exists(ret_2)) {
|
|
ret = ret_2;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
std::string get_stack_trace() {
|
|
std::ostringstream oss;
|
|
constexpr int max_frames = 64;
|
|
void* stack[max_frames]{};
|
|
|
|
const int stack_size = backtrace(stack, max_frames);
|
|
char** symbols = backtrace_symbols(stack, stack_size);
|
|
if (!symbols) {
|
|
oss << "Error retrieving stack symbols\n";
|
|
return oss.str();
|
|
}
|
|
|
|
const std::string addr2line = get_tool("addr2line");
|
|
const std::string cppfilt = get_tool("c++filt");
|
|
const std::string exe = get_exe_path();
|
|
|
|
oss << "addr2line: " << addr2line << '\n';
|
|
oss << "cppfilt: " << cppfilt << '\n';
|
|
oss << "Stack trace: " << exe << '\n';
|
|
|
|
for (int i = 0; i < stack_size; ++i) {
|
|
const auto addr = reinterpret_cast<std::uintptr_t>(stack[i]);
|
|
oss << "【" << std::dec << std::left << std::setw(2) << i << "】";
|
|
|
|
char cmd[4096];
|
|
std::snprintf(cmd, sizeof(cmd),
|
|
R"(%s -e "%s" -f -i 0x%lx | %s)",
|
|
addr2line.c_str(), exe.c_str(), static_cast<unsigned long>(addr), cppfilt.c_str());
|
|
|
|
std::string str = execute_command_single(cmd);
|
|
if (str.empty() && symbols[i]) {
|
|
str = symbols[i];
|
|
}
|
|
std::replace(str.begin(), str.end(), '\n', ' ');
|
|
oss << " " << str << "【0x" << std::hex << addr << std::dec << "】" << '\n';
|
|
}
|
|
|
|
free(symbols);
|
|
return oss.str();
|
|
}
|
|
|
|
std::string get_computer_serial_number() {
|
|
static const char* candidates[] = {
|
|
"/sys/class/dmi/id/product_serial",
|
|
"/sys/class/dmi/id/board_serial",
|
|
"/sys/class/dmi/id/product_uuid",
|
|
"/sys/class/dmi/id/chassis_serial"
|
|
};
|
|
|
|
for (const char* file : candidates) {
|
|
std::string value = read_first_line(file);
|
|
if (!value.empty() && value != "None" && value != "Not Specified" && value != "To Be Filled By O.E.M.") {
|
|
return value;
|
|
}
|
|
}
|
|
|
|
return "Unknown";
|
|
}
|
|
|
|
void set_current_thread_name(const std::string& name) {
|
|
std::string trimmed = name.substr(0, 15); // Linux 线程名最多 16 字节，含结尾 \0。
|
|
(void)pthread_setname_np(pthread_self(), trimmed.c_str());
|
|
}
|
|
|
|
void set_console_utf8() {
|
|
if (setlocale(LC_ALL, "") != nullptr) {
|
|
return;
|
|
}
|
|
if (setlocale(LC_ALL, "C.UTF-8") != nullptr) {
|
|
return;
|
|
}
|
|
(void)setlocale(LC_ALL, "en_US.UTF-8");
|
|
}
|
|
|
|
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();
|
|
(void)dlerror();
|
|
|
|
void* library = dlopen(library_path.c_str(), RTLD_LAZY);
|
|
if (!library) {
|
|
const char* err = dlerror();
|
|
std::cerr << library_path << " Failed to load library: "
|
|
<< (err ? err : "unknown") << '\n';
|
|
ec = std::make_error_code(std::errc::no_such_file_or_directory);
|
|
return false;
|
|
}
|
|
|
|
out = library;
|
|
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) {
|
|
dlclose(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) {
|
|
std::cerr << function_name << " function not loaded (library == nullptr)\n";
|
|
ec = std::make_error_code(std::errc::invalid_argument);
|
|
return false;
|
|
}
|
|
|
|
(void)dlerror();
|
|
void* func = dlsym(library, function_name.c_str());
|
|
const char* err = dlerror();
|
|
if (err != nullptr) {
|
|
std::cerr << "dlsym failed for " << function_name << " : " << err << '\n';
|
|
ec = std::make_error_code(std::errc::function_not_supported);
|
|
return false;
|
|
}
|
|
|
|
out = func;
|
|
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_error_message() {
|
|
const int ec = errno;
|
|
return "错误码：" + std::to_string(ec) + ": " + std::strerror(ec);
|
|
}
|
|
|
|
std::string get_error_message(ERROR_CODE_TYPE ec) {
|
|
return "错误码：" + std::to_string(ec) + ": " + std::strerror(static_cast<int>(ec));
|
|
}
|
|
|
|
ERROR_CODE_TYPE get_error_code() {
|
|
return errno;
|
|
}
|
|
|
|
void set_error_code(ERROR_CODE_TYPE code) {
|
|
errno = static_cast<int>(code);
|
|
}
|
|
|
|
std::string get_exe_path() {
|
|
std::vector<char> buffer(PATH_MAX + 1, '\0');
|
|
const ssize_t len = readlink("/proc/self/exe", buffer.data(), buffer.size() - 1);
|
|
if (len == -1) {
|
|
return "";
|
|
}
|
|
buffer[static_cast<size_t>(len)] = '\0';
|
|
return std::string(buffer.data());
|
|
}
|
|
|
|
std::string get_home_dir() {
|
|
if (const char* home = std::getenv("HOME")) {
|
|
return home;
|
|
}
|
|
|
|
struct passwd* pw = getpwuid(getuid());
|
|
if (pw && pw->pw_dir) {
|
|
return std::string(pw->pw_dir);
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
bool set_thread_priority(void* thread_ptr, int priority, bool realtime) {
|
|
if (!thread_ptr) {
|
|
return false;
|
|
}
|
|
|
|
pthread_t pthread = *static_cast<pthread_t*>(thread_ptr);
|
|
int policy = realtime ? SCHED_FIFO : SCHED_OTHER;
|
|
|
|
sched_param param{};
|
|
if (realtime) {
|
|
const int min_prio = sched_get_priority_min(policy);
|
|
const int max_prio = sched_get_priority_max(policy);
|
|
if (min_prio >= 0 && max_prio >= min_prio) {
|
|
priority = std::max(min_prio, std::min(max_prio, priority));
|
|
}
|
|
param.sched_priority = priority;
|
|
} else {
|
|
param.sched_priority = 0;
|
|
}
|
|
|
|
const int ret = pthread_setschedparam(pthread, policy, ¶m);
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool set_thread_priority(std::thread* thread, int priority, bool realtime) {
|
|
if (!thread) {
|
|
return false;
|
|
}
|
|
|
|
pthread_t pthread = thread->native_handle();
|
|
return set_thread_priority(static_cast<void*>(&pthread), priority, realtime);
|
|
}
|
|
|
|
bool set_thread_affinity(void* thread_ptr, unsigned cpu_index) {
|
|
if (!thread_ptr) {
|
|
return false;
|
|
}
|
|
|
|
if (cpu_index >= CPU_SETSIZE) {
|
|
errno = EINVAL;
|
|
return false;
|
|
}
|
|
|
|
pthread_t pthread = *static_cast<pthread_t*>(thread_ptr);
|
|
cpu_set_t cpuset;
|
|
CPU_ZERO(&cpuset);
|
|
CPU_SET(cpu_index, &cpuset);
|
|
|
|
const int ret = pthread_setaffinity_np(pthread, sizeof(cpu_set_t), &cpuset);
|
|
if (ret != 0) {
|
|
errno = ret;
|
|
std::cerr << "Error setting thread affinity: " << std::strerror(ret) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool set_thread_affinity(std::thread* thread, unsigned cpu_index) {
|
|
if (!thread) {
|
|
return false;
|
|
}
|
|
|
|
pthread_t pthread = thread->native_handle();
|
|
return set_thread_affinity(static_cast<void*>(&pthread), cpu_index);
|
|
}
|
|
|
|
std::string get_memory_info() {
|
|
auto ret = JSON::object();
|
|
ret.append({"VmRSS (MB)", read_proc_status_kb("VmRSS:") / 1024});
|
|
ret.append({"VmSize (MB)", read_proc_status_kb("VmSize:") / 1024});
|
|
ret.append({"VmPeak (MB)", read_proc_status_kb("VmPeak:") / 1024});
|
|
ret.append({"VmHWM (MB)", read_proc_status_kb("VmHWM:") / 1024});
|
|
return ret.to_json_string();
|
|
}
|
|
|
|
size_t get_system_memory() {
|
|
std::ifstream meminfo("/proc/meminfo");
|
|
std::string line;
|
|
while (std::getline(meminfo, line)) {
|
|
if (line.rfind("MemTotal:", 0) == 0) {
|
|
size_t mem_total_kb = 0;
|
|
if (std::sscanf(line.c_str(), "MemTotal: %zu kB", &mem_total_kb) == 1) {
|
|
return mem_total_kb * 1024;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t get_process_memory() {
|
|
return read_proc_status_kb("VmRSS:") * 1024;
|
|
}
|
|
|
|
} // namespace Psc
|
|
|
|
#endif // defined(__linux__)
|