Question

首先，这与作业有关。

这是一个操作系统课程，我们应该使用光纤，以便我们的系统在进行长时间计算时能够做出响应。为此，我们已经提供了保存和恢复堆栈等功能。我们的想法是，运行100次而不是for循环运行，保存堆栈并返回，执行其他操作，然后恢复功能的堆栈。

问题是提供的保存和恢复堆栈的宏被卡在无限循环中。令人惊讶的是，它被写为do {} while（false）循环，因此甚至不应该发生。

可能导致它发生的原因是什么？这是宏：

#define stack_saverestore(from_stack,to_stack) do {                  \
 asm volatile(                                                       \
   "  pushl %%eax      \n\t"                                         \
   "  pushl %%ecx      \n\t"                                         \
   "  pushl %%ebp      \n\t"                                         \
   "  pushl $1f        \n\t"                                         \
   "                   \n\t"                                         \
   "  movl  %%esp,(%0) \n\t"                                         \
   "  movl  (%1),%%esp \n\t"                                         \
   "                   \n\t"                                         \
   "  ret              \n\t"                                         \
   "1:                 \n\t"                                         \
   "  popl %%ebp       \n\t"                                         \
   "  popl %%ecx       \n\t"                                         \
   "  popl %%eax       \n\t"                                         \
  :                                                                  \
  :"a" (&from_stack), "c"  (&to_stack)                               \
  :_ALL_REGISTERS, "memory"                                          \
 );                                                                  \
} while(false)

我很确定问题不在宏本身，因为我在其他地方使用它，没有任何麻烦。我调试它时遇到问题，因为宏主要是汇编代码。

编辑：stack_saverestore背后的逻辑，

//
// Switch stacks.
//
// Algo: 
//   1. Save _c's context to stack, 
//   2. push ip of _c's restore handler
//   3. switch stacks
//   4. execute ip of _n's restore handler to restore _n's context from stack.
//
//
// stack layout: 
//  teip[-1:-32]: continuation to restore, 
//  Stack layout expected by teip:
//     ebp[ -33: -64], 
//     ebx[ -65: -96], 
//     eax[ -97:-128], 
//     Stack layout expected by eip+4:
//        Preserved.

使用细节 s：宏用于为非常基本的shell实现光纤。我正在做的事情并不重要，但基本上我正在添加大量的除数。我知道这不是最佳方式，但这不是问题所在。

void fiberFactor(addr_t* pmain_stack, addr_t* pf_stack,
        shellstate_t& shellstate) {

    addr_t & main_stack = main_stack; 
    addr_t & f_stack = f_stack;
    bool& done = shellstate.fiber_done;

    int n = shellstate.factorArg;
    int i = 1;
    int sum = 0;


    for (i = 1; i < n; i++) {
        for (int j = 0; j < 1000; j++) {
            if (n % i == 0) {
                sum = sum + i;
            }
            i++;
        }
        i--;
        shellstate.fiber_done = false;
        hoh_debug("about to switch stacks, i "<<i<<sum);
        stack_saverestore(f_stack, main_stack); //Never returns from here.
    }
//The hope is that with each iteration of the outer for loop, 
//we do some computation, and then yield execution. 
//Eventually, the computation is finished, and we set the flags here,   
//and switch out for the last time.
    for (;;) {
        shellstate.fiber_done = true;
        shellstate.fiber_do = false;
        shellstate.factorVal = sum;
        stack_saverestore(f_stack, main_stack);
    }

}


//This function is called by the shell as part of the main loop. 
//If we have to do something, as indicated by the booleans, do it.
void shell_step_fiber(shellstate_t& shellstate, addr_t& main_stack,
        addr_t& f_stack, addr_t f_array, uint32_t f_arraysize) {

    if (shellstate.resetFiber) {
        shellstate.resetFiber = false;
        stack_init3(f_stack, f_array, f_arraysize, &fiberFactor, &main_stack, &f_stack, &shellstate); //Reset the stacks.
    }

    if (shellstate.fiber_do){
        stack_saverestore(main_stack, f_stack); //Switch to fiberFactor. This works without a hitch.
    }
}

麻烦在于fiberFactor函数，我在for循环中调用了stack_saverestore。

Answer 1

有几件事正在向我发起。

首先，您的筹码需要空间来存储他们的东西。如果我正确读取内容，您的堆栈本质上是地址，可能相隔4个字节 - 并且您尝试在堆栈中存储16个字节。最终结果是当你写入一个堆栈时，你会破坏另一个堆栈。

为了纠正这个问题，我建议你自己创建一个堆栈结构，明确地为你要保存/恢复的所有内容留出空间。

typedef struct {
    uint32_t  eip;
    uint32_t  ebp;
    uint32_t  ecx;
    uint32_t  eax;
} my_stacktype_t;

当x86上的堆栈逐渐减少时，这些项目与您推送的项目的顺序相反。

接下来的事情是我只保存必要寄存器的子集。也许你的循环体只使用那些regs，但如果它改变了，你需要存储更多/不同的寄存器。我建议保存/恢复所有通用寄存器：eax，ebx，ecx，edx，esi，edi，ebp，esp和eip（希望我没有忘记一个 - 我在这里记忆了）。

我必须考虑你的用例场景是绝对肯定的，但是将堆栈存储在堆栈上至少是代码味道。根据我的经验，堆栈通常存储为全局变量或从堆中动态分配。

希望这有帮助。

Answer 2

原来错误不在循环中，而是在我的代码中 - 特别是在fiberFactor中的这一行：

addr_t & main_stack = main_stack;

这没有意义，因为传递给函数的参数是pmain_stack。改为

addr_t & main_stack = *pmain_stack;

和f_stack一样，解决了这个问题。

致@DavidWolfherd发现它。虽然为什么这会导致错误而不是stack_saverestore代码中的无限循环，但我不知道。

陷入do {} while（false）循环

2 个答案: