The short answer is that an interrupt handler, if it can be interrupted
by an interrupt, is interrupted precisely the same way anything else is
interrupted by an interrupt.
Say process X is running. If process X is interrupted, then the
interrupt handler runs. To the extent there is a context, it's still
process X, though it's now running interrupt code in the kernel (think of
the state as
interrupt if you like). If
another interrupt occurs, then the interrupt is interrupted, but there is
still no special process context. The state is now
When the second interrupt finishes, the first interrupt will resume just as
X will resume when the first interrupt finishes. Still, the only process
context is process X.
You can describe these as context switches, but they aren't like process
context switches. They're more analogous to entering and exiting the kernel
-- the process context stays the same but the execution level and unit of
code can change.