Linux C/C++ 对于SIGBUS、SIGSEGV等崩溃异常捕获实现
前段时间我们发表过类似得 Try-Catch 实现，但是该实现本身是存在局限性的，因为它们不能无视 SIGSEGV，SIGSYS，SIGTRAP等崩溃信号，对于某些3RD代码根本无法处理（这些代码没有源代码只有库，总不可能去静态反编译在改汇编）或者是短时间无法解决得内存BUG、例如毫无问题得代码在ARM平台会发生结构内存对齐问题（SIGBUS）导致强行崩溃（仅限于恶意崩溃，即运行相同代码+结构上万次以后才会发生SIGBUS提示内存对齐故障）别认为不可能，这在ARM上面存在潜在发生得可能性，解决办法查汇编查代码对所有的结构进行对齐检查，等等。
本文代码对于下文链接得扩展：
C/C++ 11 try-catch-finally 扩展（函数式）_liulilittle的博客-CSDN博客_c++ finally
假设...我们希望：类似以下的代码不要导致程序停止工作那么应该怎么处理？
int64_t llPtr = 0;
char* byPtr = (char*)llPtr;
*byPtr = rand() & 0xff;
... ...
printf("%s\n", "OK!");
我们知道上述代码务必会遭遇 “SIGSEGV” 导致崩溃并且产生 dump 文件/信息（若设置）那么我们不希望这里出现故障应该怎么做？
SIGSEGV 是可以被认为捕获得，有一个偷懒得宏定义叫做 SIG_IGN（忽略信号）但要注意，它的确忽略信号，确保程序不会因为崩溃信号停止工作，但这是有限度的，类似 SIGSEGV、SIGBUS 等信号是无效的，不要考虑这种没有意义得东西，就算要放弃某个信号也不应该是这么粗放式得操作，SIG_IGN 这类型仅适用于程序主动得 raise 得崩溃信号，比如：SIG_PIPE。
OK，那么可以适用最新改进得：“Try-Catch-Finally” 进行处理，但发生异常时可能潜在导致内存泄漏问题。
Try([] {
int64_t llPtr = 0;
char* byPtr = (char*)llPtr;
*byPtr = rand() & 0xff;
}).Catch
printf("%s\n", "Error!");
});
printf("%s\n", "OK!");
以上代码是可以正确执行到 OK！部分，并且不会发生内存泄漏问题，但一旦我们在 lambda 内操作关于内存相关的东西就有可能发生异常，比如在函数内复制了一个 shared_ptr 并且在析构以前出现异常，那么 shared_ptr 得引用就无法在减少导致内存资源泄露，那么类似得好办法是不要使用 shared_ptr，或者在可以确定不会发生异常得情况下使用，如果你真不确定还非得头铁用得话，有个办法：weak_ptr 可能很适合您。
潜在发生异常得 lambda 函数是可以捕获类似 shared_ptr 之类的东西，它们并不会引起不能调用捕获 shared_ptr 得析构函数，所以是是线上内存安全的，但是 lambda 内部操作不是内存安全的，这个必须要说清楚！
Try.h
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifndef MAX_STACK_FRAME
#define MAX_STACK_FRAME 10
#endif
namespace My {
class Try {
private:
typedef sigjmp_buf Context;
struct Stack {
private:
mutable std::shared_ptr rbp;
mutable Context* rsp;
public:
Stack();
void New() const;
void Release() const;
inline Context* Ptr() const {
return this->rbp.get();
}
inline Context* Push() const {
Context* max = this->rbp.get() + MAX_STACK_FRAME;
if (this->rsp >= max) {
return NULL;
}
return this->rsp++;
}
inline Context* Pop() const {
if (this->rsp <= this->rbp.get()) {
return NULL;
}
return --this->rsp;
}
inline Context* Peek() const {
Context* max = this->rbp.get() + MAX_STACK_FRAME;
if (this->rsp > max || this->rsp <= this->rbp.get()) {
return NULL;
}
return this->rsp - 1;
}
};
typedef std::unordered_map StackTable;
friend class Hosting;
friend class __TRY_SEH_SIGNAL__;
public:
inline Try(const std::function& block)
: ___try(block) {
if (!block) {
throw std::runtime_error("The block part of the try is not allowed to be Null References");
}
}
inline ~Try() {
___try = NULL;
___catch = NULL;
___finally = NULL;
}
public:
template
inline Try& Catch() const {
return Catch([](TException& e) {});
}
template
inline Try& Catch(const std::function& block) const {
return Catch(block, NULL);
}
template
inline Try& Catch(const std::function& block, const std::function& when) const {
if (!block) {
throw std::runtime_error("The block part of the try-catch is not allowed to be Null References");
}
std::function previous = ___catch;
___catch = [block, previous, when](std::exception* e) {
if (previous) {
if (previous(e)) {
return true;
}
}
TException* exception = dynamic_cast(e);
if (!exception) {
return false;
}
if (when) {
if (!when(*exception)) {
return false;
}
}
if (block) {
block(*exception);
}
return true;
};
return const_cast(*this);
}
inline Try& Finally(const std::function& block) const {
___finally = block;
return const_cast(*this);
}
inline void Invoke() const {
Context* stack_context = Try::PushContext();
std::exception* stack_exception = NULL;
try {
if (!stack_context) {
___try();
}
else {
if (sigsetjmp(*stack_context, 1) == 0) {
___try();
}
else {
stack_exception = &Try::___exception;
if (___catch) {
if (___catch(stack_exception)) {
stack_exception = NULL;
}
}
}
}
}
catch (std::exception& throwable) {
stack_exception = &throwable;
if (___catch) {
if (___catch(stack_exception)) {
stack_exception = NULL;
}
}
}
catch (...) {
stack_exception = &Try::___exception;
if (___catch) {
if (___catch(stack_exception)) {
stack_exception = NULL;
}
}
}
if (___finally) {
___finally();
}
if (stack_context) {
Try::PopContext();
}
if (stack_exception) {
throw *stack_exception;
}
}
#ifndef ANDROID
static void PrintStackTrace();
#endif
private:
static Context* PushContext();
static Context* PopContext();
static Context* PeekContext();
static void AllocStack(bool important);
static void ReleaseStack();
private:
mutable std::function ___try;
mutable std::function ___catch;
mutable std::function ___finally;
static std::runtime_error ___exception;
static std::mutex ___syncobj;
static StackTable ___stack;
static struct sigaction ___osas[15];
};
} Try.cpp
#include
#include
#include
#include
#ifndef ANDROID
#include
#include
#include
#endif
#include
#include
#ifndef ANDROID
#define MAX_BACKTRACE_SIZE 100
#endif
namespace My {
class __TRY_SEH_SIGNAL__ {
public:
inline __TRY_SEH_SIGNAL__() {
memset(Try::___osas, 0, sizeof(Try::___osas));
/*retrieve old and set new handlers*/
/*restore prevouis signal actions*/
#ifdef ANDROID
Watch(35, 0); // FDSCAN(SI_QUEUE)
#endif
Watch(SIGBUS, 1);
Watch(SIGPIPE, 2);
Watch(SIGFPE, 3);
Watch(SIGSEGV, 4);
Watch(SIGILL, 5);
Watch(SIGTRAP, 6);
Watch(SIGSYS, 7);
Watch(SIGQUIT, 8);
Watch(SIGIOT, 9);
Watch(SIGUSR1, 10);
Watch(SIGUSR2, 11);
Watch(SIGXCPU, 12);
Watch(SIGXFSZ, 13);
Watch(SIGSTKFLT, 14);
}
inline ~__TRY_SEH_SIGNAL__() {
struct sigaction* osas = Try::___osas;
/*restore prevouis signal actions*/
#ifdef ANDROID
Unwatch(35, 0); // FDSCAN(SI_QUEUE)
#endif
Unwatch(SIGBUS, 1);
Unwatch(SIGPIPE, 2);
Unwatch(SIGFPE, 3);
Unwatch(SIGSEGV, 4);
Unwatch(SIGILL, 5);
Unwatch(SIGTRAP, 6);
Unwatch(SIGSYS, 7);
Unwatch(SIGQUIT, 8);
Unwatch(SIGIOT, 9);
Unwatch(SIGUSR1, 10);
Unwatch(SIGUSR2, 11);
Unwatch(SIGXCPU, 12);
Unwatch(SIGXFSZ, 13);
Unwatch(SIGSTKFLT, 14);
}
public:
inline int Watch(int signo, int index) {
struct sigaction sa;
struct sigaction* osas = Try::___osas;
memset(&sa, 0, sizeof(sa));
/*init new handler struct*/
sa.sa_handler = [] (int signo) {
Try::Context* context = Try::PeekContext();
if (context) {
siglongjmp(*context, 1);
} else {
#ifndef ANDROID
Try::PrintStackTrace();
#endif
signal(signo, SIG_DFL);
raise(signo);
}
};
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
return sigaction(signo, &sa, &osas[index]);
}
inline int Unwatch(int signo, int index) {
struct sigaction* osas = Try::___osas;
return sigaction(signo, &osas[index], NULL);
}
} g__TRY_SEH_SIGNAL__;
std::unordered_map Try::___stack;
std::mutex Try::___syncobj;
std::runtime_error Try::___exception("Received an error signal thrown by the system or application during code execution.");
struct sigaction Try::___osas[15];
Try::Stack::Stack()
: rbp(NULL)
, rsp(NULL) {
this->New();
}
void Try::Stack::New() const {
this->rbp = make_shared_alloc(MAX_STACK_FRAME);
this->rsp = this->rbp.get();
}
void Try::Stack::Release() const {
this->rbp = NULL;
this->rsp = NULL;
}
Try::Context* Try::PushContext() {
std::lock_guard scope(Try::___syncobj);
return Try::___stack[Hosting::GetCurrentThreadId()].Push();
}
Try::Context* Try::PopContext() {
std::lock_guard scope(Try::___syncobj);
return Try::___stack[Hosting::GetCurrentThreadId()].Pop();
}
Try::Context* Try::PeekContext() {
std::lock_guard scope(Try::___syncobj);
return Try::___stack[Hosting::GetCurrentThreadId()].Peek();
}
void Try::AllocStack(bool important) {
std::lock_guard scope(Try::___syncobj);
int id = Hosting::GetCurrentThreadId();
StackTable::iterator kv = Try::___stack.find(id);
if (kv != Try::___stack.end()) {
const Stack& stack = kv->second;
if (important || !stack.Ptr()) {
stack.New();
}
}
else {
Stack stack;
Try::___stack.insert(std::make_pair(id, stack));
}
}
void Try::ReleaseStack() {
std::lock_guard scope(Try::___syncobj);
StackTable::iterator kv = Try::___stack.find(Hosting::GetCurrentThreadId());
if (kv != Try::___stack.end()) {
const Stack& stack = kv->second;
stack.Release();
Try::___stack.erase(kv);
}
}
#ifndef ANDROID
void Try::PrintStackTrace() {
char maps_string[1000] = "0";
sprintf(maps_string, "cat /proc/%d/maps", getpid());
system(maps_string);
{
printf("\nStack Addresses:\n");
_Unwind_Backtrace([](struct _Unwind_Context* context, void* arg) -> _Unwind_Reason_Code {
uintptr_t pc = _Unwind_GetIP(context);
if (pc) {
printf(" at pc:0x%llx\n", (unsigned long long)pc);
}
return _URC_NO_REASON;
}, 0); // _Unwind_Reason_Code rc, rc == _URC_END_OF_STACK ? 0 : -1;
}
void* stack_frames[MAX_BACKTRACE_SIZE];
int nptrs = backtrace(stack_frames, MAX_BACKTRACE_SIZE);
{
printf("\nStack Frame: %d\n", nptrs);
}
char** frame_strings = backtrace_symbols(stack_frames, nptrs);
if (NULL != frame_strings) {
for (int i = 0; i < nptrs; i++) {
printf(" at [%02d] %s\n", i, frame_strings[i]);
}
free(frame_strings);
}
}
#endif
}