Re: why does this program crash while using setcontext?

[Steven Smith <sos22@cam.ac.uk>]

[-- Attachment #1: Type: text/plain, Size: 2417 bytes --]

One day, I'll learn to think before posting, and possibly check
that whatever I'm suggesting actually works...

> One thing I dont understand is why if I use setcontext instead of
> swapcontext in the following program, I crash?  Look at where I
> commented out my swapcontext
The problem here is that the foo context is being invoked twice
with the same set of registers, but a different stack setup.

The first time foo is invoked, it runs through one(), setting up a
return stack in the stack buffer, before invoking the main context.
The main context then re-invokes the foo context, which returns back
through its call stack, destroying it in the process.  main then
invokes foo again, resulting in weird stack corruption problems
and a crash.  One possible fix is shown below.

> #include <ucontext.h>
> #include <stdio.h>
> #include <setjmp.h>
> 
> ucontext_t mainucp;
> ucontext_t fooucp;
> 
> char stack[SIGSTKSZ];
Add another stack buffer:
char ostack[SIGSTKSZ];

<snip unchanged code>
> int main()
> {
Add
	volatile int count;
	count = 0;
This counts the number of times the main context has resumed.

>     getcontext(&fooucp);
>     fooucp.uc_link = &mainucp;
Note that when the foo context returns, the main context is invoked
immediately i.e. without trying to save foo's registers
(which wouldn't actually make much sense).  This means that
the foo context now contains registers suitable for running
foo(), but a stack suitable for running the end of one().  This
is a bad thing.

>     fooucp.uc_stack.ss_sp = stack;
>     fooucp.uc_stack.ss_size = sizeof(stack);
>     makecontext(&fooucp, one, 0);
>     getcontext(&mainucp);
Add
	if (count == 1) {
		memcpy(ostack, stack, sizeof(stack));
	} else if (count > 1) {
		memcpy(stack, ostack, sizeof(stack));
	}
	count++;
This saves a copy of the foo context's stack the first time it switches
to main, and then restores it on later occasions.  This is ugly,
but it's probably the only way you're going to be able to re-use
contexts which have returned.

>     printf("(1, 2.2) main checking flag flag\n");
>     if (!flag)
>     {
>         setcontext(&fooucp);
>     }
>     else
>     {
>         printf("(2.5) main again\n");
>         setcontext(&fooucp);
>     }
> }

I should probably apologise for not going into nearly enough detail
for such an obscure API.

Steven.

[-- Attachment #2: Type: application/pgp-signature, Size: 189 bytes --]