setcontext was specified in POSIX.1-2001 and the Single Unix Specification, version 2, but not all Unix-likeoperating systems provide them. POSIX.1-2004 obsoleted these functions, and in POSIX.1-2008 they were removed, with POSIX Threads indicated as a possible replacement. Citing IEEE Std 1003.1, 2004 Edition:
With the incorporation of the ISO/IEC 9899:1999 standard into this specification it was found that the ISO C standard specifies that the use of function declarators with empty parentheses is an obsolescent feature. Therefore, using the function prototype: is making use of an obsolescent feature of the ISO C standard. Therefore, a strictly conforming POSIX application cannot use this form. Therefore, use of getcontext, makecontext, and swapcontext is marked obsolescent. There is no way in the ISO C standard to specify a non-obsolescent function prototype indicating that a function will be called with an arbitrary number of arguments of arbitrary types.
Definitions
The functions and associated types are defined in the ucontext.h system header file. This includes the ucontext_t type, with which all four functions operate: typedef struct ucontext_t;
uc_link points to the context which will be resumed when the current context exits, if the context was created with makecontext. uc_sigmask is used to store the set of signals blocked in the context, and uc_stack is the stack used by the context. uc_mcontext stores executionstate, including all registers and CPU flags, the instruction pointer, and the stack pointer; mcontext_t is an opaque type. The functions are:
int setcontext
:This function transfers control to the context in ucp. Execution continues from the point at which the context was stored in ucp. setcontext does not return.
int getcontext
:Saves current context into ucp. This function returns in two possible cases: after the initial call, or when a thread switches to the context in ucp via setcontext or swapcontext. The getcontext function does not provide a return value to distinguish the cases, so the programmer must use an explicit flag variable, which must not be a register variable and must be declared volatile to avoid constant propagation or other compiler optimisations.
void makecontext, int argc,...)
:The makecontext function sets up an alternate thread of control in ucp, which has previously been initialised using getcontext. The ucp.uc_stack member should be pointed to an appropriately sized stack; the constant SIGSTKSZ is commonly used. When ucp is jumped to using setcontext or swapcontext, execution will begin at the entry point to the function pointed to by func, with argc arguments as specified. When func terminates, control is returned to ucp.uc_link.
int swapcontext
:Transfers control to ucp and saves the current execution state into oucp.
Example
The example below demonstrates an iterator using setcontext.
include
include
include
/* The three contexts: * main_context1 : The point in main to which loop will return. * main_context2 : The point in main to which control from loop will * flow by switching contexts. * loop_context : The point in loop to which control from main will * flow by switching contexts. */ ucontext_t main_context1, main_context2, loop_context; /* The iterator return value. */ volatile int i_from_iterator; /* This is the iterator function. It is entered on the first call to * swapcontext, and loops from 0 to 9. Each value is saved in i_from_iterator, * and then swapcontext used to return to the main loop. The main loop prints * the value and calls swapcontext to swap back into the function. When the end * of the loop is reached, the function exits, and execution switches to the * context pointed to by main_context1. */ void loop int main
NOTE: this example is not correct, but may work as intended in some cases. The function makecontext requires additional parameters to be type int, but the example passes pointers. Thus, the example may fail on 64-bit machines > sizeof. This problem can be worked around by breaking up and reconstructing 64-bit values, but that introduces a performance penalty. For get and set context, a smaller context can be handy:
