getcontext(), setcontext() — get and set current user context; DEPRECATED
int getcontext(ucontext_t *ucp);
int setcontext(const ucontext_t *ucp);
function initializes the structure pointed to by
to the current user context of the
calling process. The
points to defines the user context and includes the
contents of the calling process' machine registers,
the signal mask, and the current execution stack.
function restores the user context pointed to by
A successful call to
does not return; program execution resumes at the point specified by the
argument passed to
argument should be created either by a prior call to
or by being passed as an argument to a signal handler.
argument was created with
program execution continues as if the corresponding call of
had just returned. If the
argument was created with
program execution continues with the function passed to
When that function returns, the process continues as if after a call to
argument that was input to
argument was passed to a signal handler, program execution continues
with the program instruction following the instruction
interrupted by the signal. If the
member of the
structure pointed to by the
argument is equal to 0, then this context is the main context, and
the process will exit when this context returns. The effects of
argument obtained from any other source are unspecified.
On successful completion,
does not return and
returns 0. Otherwise, a value of -1 is returned.
are deprecated and should be used only by legacy applications.
Context APIs are not recommended due to possible compatibility
problems from release to release,
because context APIs are very architecture-specific.
The context APIs "expose" the architecture to the application, such
that the application may not be compatible with all releases.
If you must use context APIs, be aware of the following:
Do not copy the context yourself. It is not contiguous.
The context may have pointers that may point back to the
original context rather than in the copied context; hence,
it will be broken.
The size of the context will vary in length from release to release.
No errors are defined.
When a signal handler is executed, the current user
context is saved and a new context is created. If
the process leaves the signal handler via
then it is unspecified whether the context at the
time of the corresponding
call is restored and thus whether future calls to
will provide an accurate representation of the current
context, since the context restored by
may not contain all the information that
requires. Signal handlers should use
Portable applications should not modify or access the
A portable application cannot assume that context includes
any process-wide static data, possibly including
Users manipulating contexts should take care to
handle these explicitly when required.