setjmp&longjmp的问题

dieken_qfz

碰到一个麻烦的问题, 想要用setjmp/longjmp解决，问题是这两个函数不会保存堆栈，
只是保存修改寄存器，因此在从里向外longjmp是安全的，从外向里longjmp则局部变量
会出问题。

下面是一个示例代码，从main跳到f1，再跳回main，在这一跳中必须要先保存
堆栈否则f1的局部变量就会丢失，再跳到f1，再返回到main。

想要实现的效果是: 在第二次main跳到f1之后，对于f1来说，似乎就是从switch(setjmp...)
返回1开始执行， 但是下面的代码有问题，总是f1的局部变量b,c被setjmp的返回值和参数地址
所覆盖。

代码只能用gcc编译，因为使用的jmp_buf实现是gcc特有的， 我用的gcc3.3.5，setjmp/
longjmp的实现看了看glibc的i386/setjmp/longjmp代码，大概知道怎么回事。

另外restorestack是有问题的，可能缺页或者访问非法内存，不过我运行的时候倒没
出现这些问题。

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <setjmp.h>
   
5. 
   
6. /*
   
7. # define JB_BX        0
   
8. # define JB_SI        1
   
9. # define JB_DI        2
   
10. # define JB_BP        3
    
11. # define JB_SP        4
    
12. # define JB_PC        5
    
13. */
    
14. 
    
15. #define JMPBUF(buf, idx) (((int*)buf)[idx])
    
16. #define BX(buf) JMPBUF(buf, 0)
    
17. #define SI(buf) JMPBUF(buf, 1)
    
18. #define DI(buf) JMPBUF(buf, 2)
    
19. #define BP(buf) JMPBUF(buf, 3)
    
20. #define SP(buf) JMPBUF(buf, 4)
    
21. #define PC(buf) JMPBUF(buf, 5)
    
22. 
    
23. #define savestack() if (NULL != sp1 && NULL != sp2) { \
    
24.         for (i=0; i < sp1 - sp2; ++i) { \
    
25.                 stack[i] = *(sp2 + i);  \
    
26.         } \
    
27.         } else abort();
    
28. 
    
29. #define restorestack() if (NULL != sp1 && NULL != sp2) { \
    
30.         for (i=0; i < sp1 - sp2; ++i) { \
    
31.                 *(sp2 + i) = stack[i];  \
    
32.         } \
    
33.         } else abort();
    
34. 
    
35. jmp_buf buf1;
    
36. jmp_buf buf2;
    
37. int j1 = 1;
    
38. int j2 = 1;
    
39. int i = 0;
    
40. int* sp1 = NULL;
    
41. int* sp2 = NULL;
    
42. int stack[1024];
    
43. 
    
44. void output(jmp_buf buf) {
    
45.         int* p = (int*)buf;
    
46.         int  i = 0;
    
47.         printf("BX=%u, SI=%u, DI=%u, BP=%u, SP=%u, PC=%u\n",
    
48.                         p[0], p[1], p[2], p[3], p[4], p[5]);
    
49.         printf("stack from SP: ");
    
50.         for (i = 0; i < 30; ++i) {
    
51.                 printf("%u ", *(int*)(p[4] + i));
    
52.         }
    
53.         printf("\n&output()=%u, p =%u, buf=%u\n", output, p, (int*)buf);
    
54. }
    
55. 
    
56. void f1() {
    
57.         int a = 6;
    
58.         int b = 7;
    
59.         int c = 8;
    
60.         printf("f1: enter: \t\ta=%x, b=%x, c=%x\n", a, b, c);
    
61.         switch (setjmp(buf2)) {
    
62.                 case 0:
    
63.                         sp2 = (int*)SP(buf2);
    
64.                         printf("f1: case 0: \t\ta=%x, b=%x, c=%x\n", a, b, c);
    
65.                         savestack();
    
66.                         if (j1) longjmp(buf1, 1);
    
67.                         printf("f1: case 0: after longjump\n");
    
68.                         break;
    
69.                 case 1:
    
70.                         printf("f1: case 1: jump from main\n");
    
71.                         printf("f1: \t\ta=%x, b=%x, c=%x\n", a, b, c);
    
72.                         printf("&buf1=%x, &buf2=%x, &a=%x, &b=%x, c=%x\n", &buf1, &buf2,
    
73.                                         &a, &b, &c);
    
74.                         break;
    
75.         }
    
76.         printf("f1: leave: \t\ta=%x, b=%x, c=%x\n", a, b, c);
    
77. }
    
78. int main(int argc, char** argv) {
    
79.         int x = 3;
    
80.         int y = 4;
    
81.         int z = 5;
    
82.         (void)argc;
    
83.         (void)argv;
    
84.         printf("main: enter: \t\tx=%x, y=%x, z=%x\n", x, y, z);
    
85.         switch (setjmp(buf1)) {
    
86.                 case 0:
    
87.                         sp1 = (int*)SP(buf1);
    
88.                         printf("main: case 0: call f1(): \t\tx=%x, y=%x, z=%x\n", x, y, z);
    
89.                         f1();
    
90.                         printf("main: case 0: back from f1()\n");
    
91.                         break;
    
92.                 case 1:
    
93.                         printf("main: case 1\n");
    
94.                         {
    
95.                                 int aa[512];
    
96.                                 int i;
    
97.                                 for (i=0; i < 512; ++i) {
    
98.                                         aa[i] = 512 - i;
    
99.                                 }
    
100.                         }
     
101.                         printf("main: case 1: jump to f1(): \t\tx=%x, y=%x, z=%x\n", x, y, z);
     
102.                         restorestack();
     
103.                         if (j2) longjmp(buf2, 1);
     
104.                         printf("main: case 1: back from f1()\n");
     
105.                         break;
     
106.         }
     
107.         printf("main: leave: \t\tx=%x, y=%x, z=%x\n", x, y, z);
     
108.         return 0;
     
109. }
     

复制代码

dieken_qfz

事情是这样的：
func1() ->func2()->func3() ->func4() ->.... ->funcN();

funcN()有可能引起阻塞，会返回WDBLOCK，这样func4, func3等一层一层返回这个
WDBLOCK就可以退出调用，但是中间这些代码是已经写好的，改接口很麻烦，而且每个函数
都得有一个ｉｎｔ　ｓｔａｇｅ变量记录运行到哪一步了，再ｓｗｉｔｃｈ　ｇｏｔｏ过去，造成
维护非常的不方便，　所以才想到用ｓｅｔｊｍｐ／ｌｏｎｇｊｍｐ的办法。

系统必须是单线程的（其实是一个运行于一个ＯＳ进程／线程里的一个ＪＶＭ）。

上面这个解决办法还要考虑Ｊａｖａ线程中止后这些未运行结束的函数中分配的
资源比如内存／文件等等的释放，头大。。。要将代码修改量降到最少。。。

dieken_qfz

各位对汇编熟悉的朋友帮帮忙，看看那个程序是什么原因出错，该怎么改，谢谢！

kj501

>>总是f1的局部变量b,c被setjmp的返回值和参数地址所覆盖。

我试过了，把a,b,c声明成static的静态变量，可以使它们的值不受影响。

dieken_qfz

那是当然，static变量不保存在堆栈里头，应该在程序的数据段里，相当于一个只有这个函数可见（编译
器搞的鬼）的全局变量。

我这个地方必须要用局部变量，因为这些函数不是我写的， 我不能把每个变量改成static.

kj501

既然如此，关键在于你如何去恢复stack。我不认为你这种恢复stack的办法是可靠的。但我所学有限，也想不出什么好办法。

dieken_qfz

怎么删除帖子?

dieken_qfz

恢复堆栈应该用push安全些,直接mov不安全。

我做这个东西也是无奈之举，系统比较特殊，限定了只能一个OS进程/线程，jvm
中所有本地方法都是共用的一个堆栈，而且本地方法的调用不会半途中断（就是说
从Java bytecode->kni->native c function, 然后必须返回到java bytecode
中去),  所以不会有两个Java线程程同时访问堆栈的情况，这种特殊情况下拷贝堆栈应该是安全的,
也是解决我碰到的问题的一个省事的办法.
目前感觉思路还是对的，无奈汇编功底差了，调试了好久都没搞定。

多谢回复!

rickxbx

Post by dieken_qfz

#define savestack() if (NULL != sp1 && NULL != sp2) { \
        for (i=0; i < sp1 - sp2; ++i) { \
                stack = *(sp2 + i);  \
        } \
        } else abort();

#define restorestack() if (NULL != sp1 && NULL != sp2) { \
        for (i=0; i < sp1 - sp2; ++i) { \
                *(sp2 + i) = stack;  \
        } \
        } else abort();

这里, i 太小了, 把 i<sp1-sp2 改为 i < sp1-sp2+20 差不多够了

Post by dieken_qfz

void f1() {
        int a = 6;
        int b = 7;
        int c = 8;
        printf("f1: enter: \t\ta=%x, b=%x, c=%x\n", a, b, c);
        switch (setjmp(buf2)) {
                case 0:
                        sp2 = (int*)SP(buf2);
                        printf("f1: case 0: \t\ta=%x, b=%x, c=%x\n", a, b, c);
                        savestack();
                        if (j1) longjmp(buf1, 1);
                        printf("f1: case 0: after longjump\n");
                        break;
                case 1:
                        printf("f1: case 1: jump from main\n");
                        printf("f1: \t\ta=%x, b=%x, c=%x\n", a, b, c);
                        printf("&buf1=%x, &buf2=%x, &a=%x, &b=%x, c=%x\n", &buf1, &buf2,
                                        &a, &b, &c);
                        break;
        }
        printf("f1: leave: \t\ta=%x, b=%x, c=%x\n", a, b, c);
}

restorestack() 从main函数中移置case 1 的后面

该完这两个地方,试试看,看还有什么问题

dieken_qfz

试过了, 我多拷贝了30个整型都不对。

Post by rickxbx
这里, i 太小了, 把 i<sp1-sp2 改为 i < sp1-sp2+20 差不多够了


restorestack() 从main函数中移置case 1 的后面

该完这两个地方,试试看,看还有什么问题

不能移到case 1的后面，如果如此，后面的for循环会修改堆栈，就白restore了。