C : Multithreading using ucontext/Floating point exception(core dumped)

Question

我正在尝试使用 ucontext 例程来实现多线程库。运行此代码时出现“浮点异常(核心已转储)”。

#include <stdio.h>
#include <stdlib.h>
#include <ucontext.h>

typedef struct {
    ucontext_t context;
}MyThread;

#define MAX 10
MyThread queue[MAX];
int rear=0,front=0;

void addToQueue(MyThread t)
{
    if(rear==MAX)
    {
        printf("Queue is full!");
        return;
    }

    queue[front]=t;
    front+=1;
}

MyThread* removeFromQueue()
{

    if(front==rear)
    return NULL;

    rear=rear+1;
    return &(queue[rear-1]);

}

static void func12(void)
{
    printf("func12: started\n");
}

static MyThread umain;


MyThread MyThreadCreate (void(*start_funct)(void *), void *args)
{

    MyThread newthread;
    getcontext(&(newthread.context));
    char stck[30];
    newthread.context.uc_stack.ss_sp =stck;
    newthread.context.uc_stack.ss_size = sizeof(stck);
    newthread.context.uc_link =&(umain.context);
    printf("Inside the mythreadcreate before makecontext \n");
    makecontext(&newthread.context,**(void(*)(void))start_funct,1, args);**
    printf("Inside the mythreadcreate after  makecontext \n");
    addToQueue(newthread);

    return newthread;

}

void MyThreadYield(void)
{

    MyThread* a=removeFromQueue();
    printf("Before swapping the context \n");
    swapcontext(&umain.context,&(a->context));

    printf("After the swapping the context \n");
}


int main(void)
{

    int i=0;

    printf("Inside the main \n");

    MyThreadCreate(func12,&i);

    //getcontext(&(umain.context));

    MyThreadYield();



}

返回的输出:

Inside the main  
Inside the mythreadcreate before makecontext  
Inside the mythreadcreate after  makecontext  
Before swapping the context  
func12: started  
Floating point exception (core dumped)

更新:在函数调用中添加了 (void(*)(void))start_funct,1, args)。删除了不必要的函数调用。

Answer 1

分配给新线程上下文的堆栈是第一个问题:

char stck[30];
newthread.context.uc_stack.ss_sp =stck;

“stck”分配在 MyThreadCreate 函数的堆栈上。一旦函数返回，它就会超出范围，因此 newthread.context.uc_stack.ss_sp 指向原始线程堆栈中某处的内存。

具体来说，新线程和新的原始线程在那一点“共享”同一个堆栈，这会导致核心转储(它们可能会覆盖自己)。为 newthread.context.uc_stack.ss_sp 分配适当的内存，用于 malloc。

现在，many platforms won't allow code to be contained in the heap .堆栈本质上包含要执行的代码指令。这将导致在执行上下文时程序失败。

上面的链接给出了有关如何允许内存段包含要执行的代码的指示。或者，一个简单的解决方案是使用堆栈上的一些内存，这些内存在不再使用上下文之前不会被丢弃(例如，在 main 中声明的数组)。