Question

任何人都可以解释一下，在嵌入式编程中，setjmp()和longjmp()函数究竟可以在哪些地方使用？我知道这些是用于错误处理的。但是我想知道一些用例。

Answer 1

错误处理
假设在嵌入许多其他函数的函数中存在内部错误，并且错误处理仅在顶级函数中有意义。

如果中间的所有函数都必须正常返回并评估返回值或全局错误变量以确定进一步处理没有意义甚至不好，那将是非常繁琐和笨拙的。

这是setjmp / longjmp有意义的情况。这些情况类似于其他语言（C ++，Java）中的异常有意义的情况。

<强>协程
除了错误处理之外，我还可以考虑另一种情况，你需要在C：

中使用setjmp / longjmp

您需要实施coroutines。

这是一个小小的演示示例。我希望它满足Sivaprasad Palas对一些示例代码的请求，并回答了TheBlastOne的问题，setjmp / longjmp如何支持corroutines的实现（尽管我认为它不基于任何非标准或新行为）。 / p>

修改
它可能是未定义的行为来执行longjmp 向下调用堆栈（请参阅MikeMB的评论;尽管我还没有机会验证）。

#include <stdio.h> #include <setjmp.h> jmp_buf bufferA, bufferB; void routineB(); // forward declaration void routineA() { int r ; printf("(A1)\n"); r = setjmp(bufferA); if (r == 0) routineB(); printf("(A2) r=%d\n",r); r = setjmp(bufferA); if (r == 0) longjmp(bufferB, 20001); printf("(A3) r=%d\n",r); r = setjmp(bufferA); if (r == 0) longjmp(bufferB, 20002); printf("(A4) r=%d\n",r); } void routineB() { int r; printf("(B1)\n"); r = setjmp(bufferB); if (r == 0) longjmp(bufferA, 10001); printf("(B2) r=%d\n", r); r = setjmp(bufferB); if (r == 0) longjmp(bufferA, 10002); printf("(B3) r=%d\n", r); r = setjmp(bufferB); if (r == 0) longjmp(bufferA, 10003); } int main(int argc, char **argv) { routineA(); return 0; }

下图显示了执行流程：

警告说明
当使用setjmp / longjmp时，要注意它们对局部变量的有效性有影响，通常不予考虑参看我的question about this topic。

Answer 2

理论上，您可以使用它们进行错误处理，这样您就可以跳出深层嵌套的调用链，而无需处理链中每个函数的处理错误。

就像每一个聪明的理论一样，当遇到现实时，它就会崩溃。您的中间函数将分配内存，获取锁，打开文件以及执行需要清理的各种不同的事情。因此，在实践中setjmp / longjmp通常是个坏主意，除非在非常有限的情况下您可以完全控制您的环境（某些嵌入式平台）。

根据我的经验，在大多数情况下，只要您认为使用setjmp / longjmp会起作用，您的程序就会清晰简单，以至于调用链中的每个中间函数调用都可以进行错误处理，或者它是如此混乱，无法修复，当你遇到错误时应该exit。

Answer 3

setjmp和longjmp的组合是“超强goto”。与EXTREME护理一起使用。但是，正如其他人所解释的那样，longjmp对于摆脱讨厌的错误情况非常有用，当你想快速get me back to the beginning时，而不是必须为18层函数滴回错误信息。

然而，就像goto一样，但更糟糕的是，你必须非常小心如何使用它。 longjmp只会让您回到代码的开头。它不会影响setjmp之间可能发生变化的所有其他状态以及返回setjmp开始的位置。因此，当您返回调用setjmp的位置时，仍会分配，锁定和半初始化分配，锁定，半初始化数据结构等。这意味着，您必须真正关心您执行此操作的位置，确实可以调用longjmp而不会导致更多问题。当然，如果您接下来要做的是“重新启动”[在存储有关错误的消息之后，可能] - 例如，在您发现硬件状态不佳的嵌入式系统中，那么就好了。 / p>

我还看到setjmp / longjmp用于提供非常基本的线程机制。但这是非常特殊的情况 - 绝对不是“标准”线程如何工作。

编辑：当然可以添加代码来“处理清理”，就像C ++在编译代码中存储异常点一样，然后知道什么是异常以及需要清理的内容。这将涉及某种函数指针表并存储“如果我们从这里跳出来，请使用此参数调用此函数”。像这样：

struct 
{
    void (*destructor)(void *ptr);
};


void LockForceUnlock(void *vlock)
{
   LOCK* lock = vlock;
}


LOCK func_lock;


void func()
{
   ref = add_destructor(LockForceUnlock, mylock);
   Lock(func_lock)
   ... 
   func2();   // May call longjmp. 

   Unlock(func_lock);
   remove_destructor(ref);
}

使用此系统，您可以“像C ++一样完成异常处理”。但它非常混乱，并依赖于编写良好的代码。

Answer 4

由于您提到嵌入式，我认为值得注意的是非用例：当您的编码标准禁止它时。例如MISRA（MISRA-C：2004：规则20.7）和JFS（AV规则20）：“不应使用setjmp宏和longjmp函数。”

Answer 5

setjmp和longjmp在单元测试中非常有用。

假设我们要测试以下模块：

#include <stdlib.h>

int my_div(int x, int y)
{
    if (y==0) exit(2);
    return x/y;
}

通常，如果要测试的函数调用另一个函数，则可以声明一个存根函数，以便调用它来模拟实际函数测试某些流的功能。但是，在这种情况下，函数调用exit并且不返回。存根需要以某种方式模拟此行为。 setjmp和longjmp可以为您做到这一点。

要测试此功能，我们可以创建以下测试程序：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <setjmp.h>

// redefine assert to set a boolean flag
#ifdef assert
#undef assert
#endif
#define assert(x) (rslt = rslt && (x))

// the function to test
int my_div(int x, int y);

// main result return code used by redefined assert
static int rslt;

// variables controling stub functions
static int expected_code;
static int should_exit;
static jmp_buf jump_env;

// test suite main variables
static int done;
static int num_tests;
static int tests_passed;

//  utility function
void TestStart(char *name)
{
    num_tests++;
    rslt = 1;
    printf("-- Testing %s ... ",name);
}

//  utility function
void TestEnd()
{
    if (rslt) tests_passed++;
    printf("%s\n", rslt ? "success" : "fail");
}

// stub function
void exit(int code)
{
    if (!done)
    {
        assert(should_exit==1);
        assert(expected_code==code);
        longjmp(jump_env, 1);
    }
    else
    {
        _exit(code);
    }
}

// test case
void test_normal()
{
    int jmp_rval;
    int r;

    TestStart("test_normal");
    should_exit = 0;
    if (!(jmp_rval=setjmp(jump_env)))
    {
        r = my_div(12,3);
    }

    assert(jmp_rval==0);
    assert(r==4);
    TestEnd();
}

// test case
void test_div0()
{
    int jmp_rval;
    int r;

    TestStart("test_div0");
    should_exit = 1;
    expected_code = 2;
    if (!(jmp_rval=setjmp(jump_env)))
    {
        r = my_div(2,0);
    }

    assert(jmp_rval==1);
    TestEnd();
}

int main()
{
    num_tests = 0;
    tests_passed = 0;
    done = 0;
    test_normal();
    test_div0();
    printf("Total tests passed: %d\n", tests_passed);
    done = 1;
    return !(tests_passed == num_tests);
}

在此示例中，您在输入要测试的函数之前使用setjmp，然后在存根exit中调用longjmp以直接返回测试用例。

另请注意，重新定义的exit有一个特殊变量，它会检查您是否确实要退出程序并调用_exit来执行此操作。如果你不这样做，你的测试程序可能不会干净利落。

Answer 6

我使用setjmp()，longjmp()和系统函数在C中编写了Java-like exception handling mechanism。它捕获自定义异常，但也包含SIGSEGV之类的信号。它具有异常处理块的无限嵌套，可以在函数调用中运行，并支持两种最常见的线程实现。它允许您定义具有链接时继承的异常类的树层次结构，catch语句遍历此树以查看它是否需要捕获或传递。

以下是使用此代码查看代码的示例：

try
{
    *((int *)0) = 0;    /* may not be portable */
}
catch (SegmentationFault, e)
{
    long f[] = { 'i', 'l', 'l', 'e', 'g', 'a', 'l' };
    ((void(*)())f)();   /* may not be portable */
}
finally
{
    return(1 / strcmp("", ""));
}

这是包含大量逻辑的包含文件的一部分：

#ifndef _EXCEPT_H
#define _EXCEPT_H

#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <setjmp.h>
#include "Lifo.h"
#include "List.h"

#define SETJMP(env)             sigsetjmp(env, 1)
#define LONGJMP(env, val)       siglongjmp(env, val)
#define JMP_BUF                 sigjmp_buf

typedef void (* Handler)(int);

typedef struct _Class *ClassRef;        /* exception class reference */
struct _Class
{
    int         notRethrown;            /* always 1 (used by throw()) */
    ClassRef    parent;                 /* parent class */
    char *      name;                   /* this class name string */
    int         signalNumber;           /* optional signal number */
};

typedef struct _Class Class[1];         /* exception class */

typedef enum _Scope                     /* exception handling scope */
{
    OUTSIDE = -1,                       /* outside any 'try' */
    INTERNAL,                           /* exception handling internal */
    TRY,                                /* in 'try' (across routine calls) */
    CATCH,                              /* in 'catch' (idem.) */
    FINALLY                             /* in 'finally' (idem.) */
} Scope;

typedef enum _State                     /* exception handling state */
{
    EMPTY,                              /* no exception occurred */
    PENDING,                            /* exception occurred but not caught */
    CAUGHT                              /* occurred exception caught */
} State;

typedef struct _Except                  /* exception handle */
{
    int         notRethrown;            /* always 0 (used by throw()) */
    State       state;                  /* current state of this handle */
    JMP_BUF     throwBuf;               /* start-'catching' destination */
    JMP_BUF     finalBuf;               /* perform-'finally' destination */
    ClassRef    class;                  /* occurred exception class */
    void *      pData;                  /* exception associated (user) data */
    char *      file;                   /* exception file name */
    int         line;                   /* exception line number */
    int         ready;                  /* macro code control flow flag */
    Scope       scope;                  /* exception handling scope */
    int         first;                  /* flag if first try in function */
    List *      checkList;              /* list used by 'catch' checking */
    char*       tryFile;                /* source file name of 'try' */
    int         tryLine;                /* source line number of 'try' */

    ClassRef    (*getClass)(void);      /* method returning class reference */
    char *      (*getMessage)(void);    /* method getting description */
    void *      (*getData)(void);       /* method getting application data */
    void        (*printTryTrace)(FILE*);/* method printing nested trace */
} Except;

typedef struct _Context                 /* exception context per thread */
{
    Except *    pEx;                    /* current exception handle */
    Lifo *      exStack;                /* exception handle stack */
    char        message[1024];          /* used by ExceptGetMessage() */
    Handler     sigAbrtHandler;         /* default SIGABRT handler */
    Handler     sigFpeHandler;          /* default SIGFPE handler */
    Handler     sigIllHandler;          /* default SIGILL handler */
    Handler     sigSegvHandler;         /* default SIGSEGV handler */
    Handler     sigBusHandler;          /* default SIGBUS handler */
} Context;

extern Context *        pC;
extern Class            Throwable;

#define except_class_declare(child, parent) extern Class child
#define except_class_define(child, parent)  Class child = { 1, parent, #child }

except_class_declare(Exception,           Throwable);
except_class_declare(OutOfMemoryError,    Exception);
except_class_declare(FailedAssertion,     Exception);
except_class_declare(RuntimeException,    Exception);
except_class_declare(AbnormalTermination, RuntimeException);  /* SIGABRT */
except_class_declare(ArithmeticException, RuntimeException);  /* SIGFPE */
except_class_declare(IllegalInstruction,  RuntimeException);  /* SIGILL */
except_class_declare(SegmentationFault,   RuntimeException);  /* SIGSEGV */
except_class_declare(BusError,            RuntimeException);  /* SIGBUS */


#ifdef  DEBUG

#define CHECKED                                                         \
        static int checked

#define CHECK_BEGIN(pC, pChecked, file, line)                           \
            ExceptCheckBegin(pC, pChecked, file, line)

#define CHECK(pC, pChecked, class, file, line)                          \
                 ExceptCheck(pC, pChecked, class, file, line)

#define CHECK_END                                                       \
            !checked

#else   /* DEBUG */

#define CHECKED
#define CHECK_BEGIN(pC, pChecked, file, line)           1
#define CHECK(pC, pChecked, class, file, line)          1
#define CHECK_END                                       0

#endif  /* DEBUG */


#define except_thread_cleanup(id)       ExceptThreadCleanup(id)

#define try                                                             \
    ExceptTry(pC, __FILE__, __LINE__);                                  \
    while (1)                                                           \
    {                                                                   \
        Context *       pTmpC = ExceptGetContext(pC);                   \
        Context *       pC = pTmpC;                                     \
        CHECKED;                                                        \
                                                                        \
        if (CHECK_BEGIN(pC, &checked, __FILE__, __LINE__) &&            \
            pC->pEx->ready && SETJMP(pC->pEx->throwBuf) == 0)           \
        {                                                               \
            pC->pEx->scope = TRY;                                       \
            do                                                          \
            {

#define catch(class, e)                                                 \
            }                                                           \
            while (0);                                                  \
        }                                                               \
        else if (CHECK(pC, &checked, class, __FILE__, __LINE__) &&      \
                 pC->pEx->ready && ExceptCatch(pC, class))              \
        {                                                               \
            Except *e = LifoPeek(pC->exStack, 1);                       \
            pC->pEx->scope = CATCH;                                     \
            do                                                          \
            {

#define finally                                                         \
            }                                                           \
            while (0);                                                  \
        }                                                               \
        if (CHECK_END)                                                  \
            continue;                                                   \
        if (!pC->pEx->ready && SETJMP(pC->pEx->finalBuf) == 0)          \
            pC->pEx->ready = 1;                                         \
        else                                                            \
            break;                                                      \
    }                                                                   \
    ExceptGetContext(pC)->pEx->scope = FINALLY;                         \
    while (ExceptGetContext(pC)->pEx->ready > 0 || ExceptFinally(pC))   \
        while (ExceptGetContext(pC)->pEx->ready-- > 0)

#define throw(pExceptOrClass, pData)                                    \
    ExceptThrow(pC, (ClassRef)pExceptOrClass, pData, __FILE__, __LINE__)

#define return(x)                                                       \
    {                                                                   \
        if (ExceptGetScope(pC) != OUTSIDE)                              \
        {                                                               \
            void *      pData = malloc(sizeof(JMP_BUF));                \
            ExceptGetContext(pC)->pEx->pData = pData;                   \
            if (SETJMP(*(JMP_BUF *)pData) == 0)                         \
                ExceptReturn(pC);                                       \
            else                                                        \
                free(pData);                                            \
        }                                                               \
        return x;                                                       \
    }

#define pending                                                         \
    (ExceptGetContext(pC)->pEx->state == PENDING)

extern Scope    ExceptGetScope(Context *pC);
extern Context *ExceptGetContext(Context *pC);
extern void     ExceptThreadCleanup(int threadId);
extern void     ExceptTry(Context *pC, char *file, int line);
extern void     ExceptThrow(Context *pC, void * pExceptOrClass,
                            void *pData, char *file, int line);
extern int      ExceptCatch(Context *pC, ClassRef class);
extern int      ExceptFinally(Context *pC);
extern void     ExceptReturn(Context *pC);
extern int      ExceptCheckBegin(Context *pC, int *pChecked,
                                 char *file, int line);
extern int      ExceptCheck(Context *pC, int *pChecked, ClassRef class,
                            char *file, int line);


#endif  /* _EXCEPT_H */

还有一个C模块，其中包含信号处理和一些簿记的逻辑。

实施起来非常棘手我可以告诉你，我几乎退出了。我真的很努力让它尽可能接近Java;我发现只有C才能让我感到惊讶。

如果你有兴趣，请给我一个喊叫。

Answer 7

不言而喻，setjmp / longjmp的最关键用途是它起到了“非本地goto跳转”的作用。 Goto命令（在少数情况下，您需要在for和while循环中使用goto over）在同一范围内使用最安全。如果使用goto在范围（或自动分配）之间跳转，则很有可能会破坏程序的堆栈。 setjmp / longjmp通过将堆栈信息保存在要跳转到的位置来避免这种情况。然后，当您跳转时，它将加载此堆栈信息。没有此功能，C程序员很可能不得不转向汇编编程来解决只有setjmp / longjmp才能解决的问题。感谢上帝，它的存在。 C库中的所有内容都非常重要。您会在需要时知道。

Answer 8

setjmp（）和longjmp（）对于处理程序的低级子例程中遇到的错误和中断很有用。

Answer 9

除了错误处理之外，您可以做的并且以前没有提到的另一件事是以聪明的方式在C语言中实现尾部递归计算。

实际上，这是在C中实现连续而不将输入代码转换为连续传递样式的方式。

C语言中setjmp和longjmp的实际用法

9 个答案: