如何捕获 Linux 中的分段错误？

Question

我需要在第三方库清理操作中捕获分段错误。这种情况有时会在我的程序退出之前发生，我无法解决其真正原因。在 Windows 编程中，我可以使用 __try - __catch 来做到这一点。是否有跨平台或特定于平台的方法可以做到这一点？我在 Linux 中需要这个，gcc。

Answer 1

在 Linux 上，我们也可以将这些作为例外。

通常，当您的程序执行分段错误时，会发送一个 SIGSEGV 信号。您可以为此信号设置自己的处理程序并减轻后果。当然，您应该真正确定自己可以从这种情况中恢复过来。对于你的情况，我认为你应该调试你的代码。

回到主题。我最近遇到了一个库 (简短手册）将此类信号转换为异常，因此您可以编写如下代码：

try
{
    *(int*) 0 = 0;
}
catch (std::exception& e)
{
    std::cerr << "Exception caught : " << e.what() << std::endl;
}

但没有检查它。 适用于我的 x86-64 Gentoo 盒子。它有一个特定于平台的后端（借用了 gcc 的 java 实现），因此它可以在许多平台上工作。它只支持开箱即用的 x86 和 x86-64，但您可以从 libjava 获取后端，它驻留在 gcc 源代码中。

Answer 2

下面是如何在 C 中执行此操作的示例。

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void segfault_sigaction(int signal, siginfo_t *si, void *arg)
{
    printf("Caught segfault at address %p\n", si->si_addr);
    exit(0);
}

int main(void)
{
    int *foo = NULL;
    struct sigaction sa;

    memset(&sa, 0, sizeof(struct sigaction));
    sigemptyset(&sa.sa_mask);
    sa.sa_sigaction = segfault_sigaction;
    sa.sa_flags   = SA_SIGINFO;

    sigaction(SIGSEGV, &sa, NULL);

    /* Cause a seg fault */
    *foo = 1;

    return 0;
}

Answer 3

为了可移植性，人们可能应该使用标准 C++ 库中的 std::signal，但是信号处理程序的功能有很多限制。不幸的是，在不引入未定义行为的情况下，不可能从 C++ 程序中捕获 SIGSEGV，因为规范指出：

1. 从处理程序内调用除非常窄的子集之外的任何库函数都是未定义行为标准库函数（abort、exit、一些原子函数、重新安装当前信号处理程序、memcpy、memmove 、类型特征、std::move、std::forward 等等）。
2. 如果处理程序使用 throw 表达式，则这是未定义的行为。
3. 如果处理程序在处理 SIGFPE、SIGILL、SIGSEGV 时返回，则这是未定义的行为

这证明使用严格标准和可移植的 C++ 不可能从程序内捕获 SIGSEGV。 SIGSEGV 仍然被操作系统捕获，并且通常在调用 wait 系列函数时报告给父进程。

使用 POSIX 信号您可能会遇到同样的麻烦，因为有一个子句在 2.4.3 信号操作：

对于不是由 kill() 生成的 SIGBUS、SIGFPE、SIGILL 或 SIGSEGV 信号，进程从信号捕获函数正常返回后，进程的行为是未定义的，sigqueue() 或 raise()。

关于跳远的一句话。假设我们使用 POSIX 信号，使用 longjump 来模拟堆栈展开不会有帮助：

虽然longjmp()是一个异步信号安全函数，但如果它是从中断非异步信号安全函数或等效函数（例如处理等效函数）的信号处理程序调用的，从初始调用 main() 返回后执行的 exit()），任何后续调用非异步信号安全函数或等效函数的行为未定义。

这意味着调用 longjump 所调用的延续无法可靠地调用通常有用的库函数，例如 printf、malloc 或 exit 或从 main 返回不会引起未定义的行为。因此，延续只能执行受限操作，并且只能通过某种异常终止机制退出。

简而言之，在不引入未定义行为的情况下，捕获 SIGSEGV 并在便携式设备中恢复程序的执行可能是不可行的。即使您在可以访问结构化异常处理的 Windows 平台上工作，值得一提的是，MSDN 建议永远不要尝试处理硬件异常：硬件异常。

最后但并非最不重要的一点是，在取消引用空值指针（或无效值指针）时是否会引发任何 SIGSEGV 不是标准的要求。因为通过空值指针或任何无效值指针进行间接访问是未定义行为，这意味着编译器假设您的代码在运行时永远不会尝试这样的事情，编译器可以自由地进行代码转换，从而消除这种未定义的行为。例如，来自 cppreference，

int foo(int* p) {
    int x = *p;
    if(!p)
        return x; // Either undefined behavior above or this branch is never taken
    else
        return 0;
}
 
int main() {
    int* p = nullptr;
    std::cout << foo(p);
}

这里 if 的真实路径可以被编译器完全忽略作为优化；只能保留 else 部分。换句话说，编译器推断 foo() 在运行时永远不会收到空值指针，因为它会导致未定义的行为。使用空值指针调用它，您可能会观察到打印到标准输出的值 0 并且没有崩溃，您可能会观察到 SIGSEG 崩溃，事实上您可以观察到任何东西，因为没有强加合理的要求存在未定义行为的程序。

Answer 4

在这里找到C++解决方案（http://www.cplusplus.com/forum/unices/16430/< /a>)

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
void ouch(int sig)
{
    printf("OUCH! - I got signal %d\n", sig);
}
int main()
{
    struct sigaction act;
    act.sa_handler = ouch;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGINT, &act, 0);
    while(1) {
        printf("Hello World!\n");
        sleep(1);
    }
}

Answer 5

有时我们想要捕获 SIGSEGV 来确定指针是否有效，即它是否引用了有效的内存地址。 （或者甚至检查某个任意值是否可能是指针。）

一种选择是使用 isValidPtr() 进行检查（适用于 Android）：

int isValidPtr(const void*p, int len) {
    if (!p) {
    return 0;
    }
    int ret = 1;
    int nullfd = open("/dev/random", O_WRONLY);
    if (write(nullfd, p, len) < 0) {
    ret = 0;
    /* Not OK */
    }
    close(nullfd);
    return ret;
}
int isValidOrNullPtr(const void*p, int len) {
    return !p||isValidPtr(p, len);
}

另一种选择是读取内存保护属性，这是一个有点棘手（适用于 Android）：

re_mrot.c:

#include <errno.h>
#include <malloc.h>
//#define PAGE_SIZE 4096
#include "dlog.h"
#include "stdlib.h"
#include "re_mprot.h"

struct buffer {
    int pos;
    int size;
    char* mem;
};

char* _buf_reset(struct buffer*b) {
    b->mem[b->pos] = 0;
    b->pos = 0;
    return b->mem;
}

struct buffer* _new_buffer(int length) {
    struct buffer* res = malloc(sizeof(struct buffer)+length+4);
    res->pos = 0;
    res->size = length;
    res->mem = (void*)(res+1);
    return res;
}

int _buf_putchar(struct buffer*b, int c) {
    b->mem[b->pos++] = c;
    return b->pos >= b->size;
}

void show_mappings(void)
{
    DLOG("-----------------------------------------------\n");
    int a;
    FILE *f = fopen("/proc/self/maps", "r");
    struct buffer* b = _new_buffer(1024);
    while ((a = fgetc(f)) >= 0) {
    if (_buf_putchar(b,a) || a == '\n') {
        DLOG("/proc/self/maps: %s",_buf_reset(b));
    }
    }
    if (b->pos) {
    DLOG("/proc/self/maps: %s",_buf_reset(b));
    }
    free(b);
    fclose(f);
    DLOG("-----------------------------------------------\n");
}

unsigned int read_mprotection(void* addr) {
    int a;
    unsigned int res = MPROT_0;
    FILE *f = fopen("/proc/self/maps", "r");
    struct buffer* b = _new_buffer(1024);
    while ((a = fgetc(f)) >= 0) {
    if (_buf_putchar(b,a) || a == '\n') {
        char*end0 = (void*)0;
        unsigned long addr0 = strtoul(b->mem, &end0, 0x10);
        char*end1 = (void*)0;
        unsigned long addr1 = strtoul(end0+1, &end1, 0x10);
        if ((void*)addr0 < addr && addr < (void*)addr1) {
            res |= (end1+1)[0] == 'r' ? MPROT_R : 0;
            res |= (end1+1)[1] == 'w' ? MPROT_W : 0;
            res |= (end1+1)[2] == 'x' ? MPROT_X : 0;
            res |= (end1+1)[3] == 'p' ? MPROT_P
                 : (end1+1)[3] == 's' ? MPROT_S : 0;
            break;
        }
        _buf_reset(b);
    }
    }
    free(b);
    fclose(f);
    return res;
}

int has_mprotection(void* addr, unsigned int prot, unsigned int prot_mask) {
    unsigned prot1 = read_mprotection(addr);
    return (prot1 & prot_mask) == prot;
}

char* _mprot_tostring_(char*buf, unsigned int prot) {
    buf[0] = prot & MPROT_R ? 'r' : '-';
    buf[1] = prot & MPROT_W ? 'w' : '-';
    buf[2] = prot & MPROT_X ? 'x' : '-';
    buf[3] = prot & MPROT_S ? 's' : prot & MPROT_P ? 'p' :  '-';
    buf[4] = 0;
    return buf;
}

re_mrot.h:

#include <alloca.h>
#include "re_bits.h"
#include <sys/mman.h>

void show_mappings(void);

enum {
    MPROT_0 = 0, // not found at all
    MPROT_R = PROT_READ,                                 // readable
    MPROT_W = PROT_WRITE,                                // writable
    MPROT_X = PROT_EXEC,                                 // executable
    MPROT_S = FIRST_UNUSED_BIT(MPROT_R|MPROT_W|MPROT_X), // shared
    MPROT_P = MPROT_S<<1,                                // private
};

// returns a non-zero value if the address is mapped (because either MPROT_P or MPROT_S will be set for valid addresses)
unsigned int read_mprotection(void* addr);

// check memory protection against the mask
// returns true if all bits corresponding to non-zero bits in the mask
// are the same in prot and read_mprotection(addr)
int has_mprotection(void* addr, unsigned int prot, unsigned int prot_mask);

// convert the protection mask into a string. Uses alloca(), no need to free() the memory!
#define mprot_tostring(x) ( _mprot_tostring_( (char*)alloca(8) , (x) ) )
char* _mprot_tostring_(char*buf, unsigned int prot);

PS DLOG() 是 printf()< /code> 到 Android 日志。 FIRST_UNUSED_BIT() 定义为 此处。

PPS 在循环中调用alloca()可能不是一个好主意——在函数返回之前内存可能不会被释放。