I'm all for radical ideas, but from a pragmatic point of view, you
shouldn't use longjmp in the kernel. Seriously bad things are happening
with it; it leaves local variables undefined, doesn't undo global state
changes.
So if you:
spin_lock(&s->lock);
if (!s->active)
longjmp(buf, -1);
... you are broken. This case can be made very much more complex and
hard to reason about by using local variables which are reset by the
longjmp.
Further, it requires use of the volatile keyword to interact properly
with logic involving more than one variable, and thus, by definition is
impossible to use in the kernel, which does not implement the volatile
keyword. :)
Instead, for this case, use the fact that there is an architecturally
designed finite number of exceptions that can be processed
simultaneously. This means if you queue exceptions to a pending list of
control-flow interrupting events to be processed, as long as the queue
is appropriately sized, you will never overflow this queue and never
require dynamic allocation. Further, you can then naturally follow the
exception priority rules at the top-level of the emulator and never need
to pass back complex exception structures, merely a simple return value
which indicates whether to return to top-level control logic or continue
with instruction emulation. I believe using this style of programming
will make your need for setjmp/longjmp go away.
Zach
--
