使用 setjmp() 和 longjmp() 来防止程序中的分段错误

Question

我已经使用 setjmp() 和 longjmp() 编写了一个程序来防止段错误，但是我编写的程序只能防止段错误发生一次（我运行ning我的代码在 while 循环中）。

这是我的代码：

#include <stdio.h>
#include <setjmp.h>
#include <signal.h>

jmp_buf buf;

void my_sig_handler(int sig)
{
    if( sig )
    {
        printf("Received SIGSEGV signl \n");
        longjmp(buf,2);
    }
}

int main()
{
    while( 1)
    {
        switch( setjmp(buf) )                       // Save the program counter
        {
        case 0:
            signal(SIGSEGV, my_sig_handler);        // Register SIGSEGV signal handler function
            printf("Inside 0 statement \n");
            int *ptr = NULL;
            printf("ptr is  %d ", *ptr);            // SEG fault will happen here
            break;
        case 2:
            printf("Inside 2 statement \n");        // In case of SEG fault, program should execute this statement
            break;
        default:
            printf("Inside default statement \n");
            break;
        }
    }
    return 0;
}

输出:

Inside 0 statement 
Received SIGSEGV signl 
Inside 2 statement 
Inside 0 statement 
Segmentation fault

预期输出：

Inside 0 statement 
Received SIGSEGV signl 
Inside 2 statement 
.
.(Infinite times)
.
Inside 0 statement 
Received SIGSEGV signal
Inside 2 statement

谁能解释一下为什么这只是第一次运行ning？另外，我在这里运行我的代码缺少什么？

Answer 1

长话短说：longjump（显然）不是一个async-signal-safe函数，printf也是。因此，从信号处理程序调用这些函数将导致未定义的行为。有关详细信息和 async-signal-safe 函数列表，请参阅 man 7 signal-safety。

最有可能发生的是 longjump(buf, 2) 导致程序异常 "escape" 信号处理程序，这会在执行第二个 switch case 后导致另一个分段错误。由于发生了另一个段错误，信号处理程序再次被调用，你又做了另一个 longjump(buf, 2)，回到你原来的位置，导致另一个段错误，等等......无限期地。

编辑：根据Andrew Henle in the comments below, there also are the two POSIX functions sigsetjmp() and siglongjmp()的建议。然而，我更喜欢下面描述的方法，因为它 对我来说看起来更干净 并且安全地 returns 从信号处理程序将脏工作留给内核。

如果您希望您的代码按预期运行，您可以让您的信号在出现段错误时接收有关上下文的信息：

static void signal_handler(int sig, siginfo_t *info, void *ucontext) {
    /* Assuming your architecture is Intel x86_64. */
    ucontext_t *uc = (ucontext_t *)ucontext;
    greg_t *rip = &uc->uc_mcontext.gregs[REG_RIP];

    /* Assign a new value to *rip somehow, which will be where the
       execution will continue after the signal handler returns. */
}

int main(void) {
    struct sigaction sa;
    int err;

    sa.sa_flags = SA_SIGINFO;
    sa.sa_sigaction = signal_handler;

    err = sigemptyset(&sa.sa_mask);
    if (err)
        return 1;

    err = sigaddset(&sa.sa_mask, SIGSEGV);
    if (err)
        return 1;

    err = sigaction(SIGSEGV, &sa, NULL);
    if (err)
        return 1;

    /* ... */

    return 0;
}

这将允许您基本上在任何您想要的地方恢复执行，前提是您确实知道确切的恢复位置。但是，要将 rip 设置为正确的值，您可能必须使用使用内联汇编或其他一些肮脏技巧定义的全局标签。

像这样的东西应该工作（在我的机器上测试）：

/* In main, where you want to retums after SIGSEGV: */
asm voaltile ("checkpoint: .global checkpoint" : );

/* In your signal handler: */
asm volatile (
    "movabs $checkpoint, %0"
    : "=r" (*rip)
);

如果你想知道为什么这不是那么容易那是因为它甚至不应该首先完成，它基本上是一种可憎的东西，除了可能发现如何破坏东西的乐趣之外没有任何目的以最荒谬的方式。

您至少需要以下 headers 和功能测试宏才能使上述功能正常工作：

#define _GNU_SOURCE
#define __USE_GNU
#include <signal.h>
#include <ucontext.h>

请注意，这（当然）取决于体系结构和平台。

使用 setjmp() 和 longjmp() 来防止程序中的分段错误

Using setjmp() and longjmp() to prevent segmentation fault in a program

c

signals

segmentation-fault

setjmp