C:使用ucontext /浮点异常的多线程(核心转储)

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)

更新:在function calls.removed不必要的函数调用中添加(void(*)(void))start_funct,1，args)。

Answer 1

分配给newthread上下文的堆栈是第一个问题：

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

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

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

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

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