如何确定执行是在线程模式下发生还是异常处于活动状态？ （ARMv7-A 架构）

Question

I am using FreeRTOS on an ARM Cortex A9 CPU und I'm desperately trying to find out if it is possible to determin if the processor is executing a normal thread or an interrupt service routine. It is implemented in V7-a architecture.

I found some promising reference hinting the ICSR register (-> VECTACTIVE bits), but this only exist in the cortex M family. Is there a comparable register in the A family as well? I tried to read out the processor modes in the current processor status register ( CPSR ), but when read during an ISR I saw that the mode bits indicate supervisor mode rather than IRQ or FIQ mode.

Looks a lot like there is no way to determine in which state the processor is, but I wanted to ask anyway, maybe I missed something...

The processor has a pl390 General Interrupt Controller. Maybe it is possible to determine the if an interrupt has been triggered by reading some of it's registers?

If anybody can give me a clue I would be very greatfull!

Thanks!

Answer 1

On a Cortex-A processor, when an interrupt handler is triggered , the processor enters IRQ mode, with interrupts disabled. This is reflected in the state field of CPSR. IRQ mode is not suitable to receive nested interrupts, because if a second interrupt happened, the return address for the first interrupt would be overwritten. So, if an interrupt handler ever needs to re-enable interrupts, it must switch to supervisor mode first.

Generally, one of the first thing that an operating system's interrupt handler does is to switch to supervisor mode. By the time the code reaches a particular driver, the processor is in supervisor mode. So the behavior you're observing is perfectly normal.

A FreeRTOS interrupt handler is a C function. It runs with interrupts enabled, in supervisor mode. If you want to know whether your code is running in the context of an interrupt handler, never call the interrupt handler function directly, and when it calls auxiliary functions that care, pass a variable that indicates who the caller is.

void code_that_wants_to_know_who_called_it(int context) {
    if (context != 0)
        // called from an interrupt handler
    else
        // called from outside an interrupt handler
}

void my_handler1(void) {
    code_that_wants_to_know_who_called_it(1);
}
void my_handler2(void) {
    code_that_wants_to_know_who_called_it(1);
}

int main(void) {
    Install_Interrupt(EVENT1, my_handler1);
    Install_Interrupt(EVENT2, my_handler1);
    code_that_wants_to_know_who_called_it(0);
}