ISR-Safe API 설계 — Reentrant·Atomic·Defer 패턴

1
/* 회피 — non-reentrant */
2
static int last_value;
3

4
int compute(int x) {
5
    last_value = x * 2;    /* ← global state */
6
    return last_value;
7
}
8

9
/* Good — reentrant */
10
int compute(int x) {
11
    return x * 2;          /* stack only */
12
}

1
char *p = strtok(s, ",");   /* ← non-reentrant (static state) */
2
int n = rand();             /* ← non-reentrant */

1
/* OK — Cortex-M 32-bit aligned */
2
volatile uint32_t isr_counter;
3

4
void ISR(void) {
5
    isr_counter++;   /* atomic on 32-bit */
6
}
7

8
void task(void) {
9
    uint32_t v = isr_counter;   /* atomic read */
10
}

1
#define SIZE 64
2
volatile uint8_t buf[SIZE];
3
volatile uint8_t head, tail;   /* ISR writes head, task reads */
4

5
void ISR(void) {
6
    uint8_t byte = UART->RDR;
7
    uint8_t next = (head + 1) % SIZE;
8
    if (next != tail) {
9
        buf[head] = byte;
10
        head = next;   /* atomic write */
11
    }
12
    /* else — overflow, drop */
13
}
14

15
void task(void) {
16
    while (tail != head) {
17
        uint8_t byte = buf[tail];
18
        tail = (tail + 1) % SIZE;
19
        process(byte);
20
    }
21
}

1
void ISR(void) {
2
    BaseType_t pxHP = pdFALSE;
3
    xQueueSendFromISR(rx_q, &byte, &pxHP);
4
    portYIELD_FROM_ISR(pxHP);
5
}

1
volatile int rx_pending = 0;
2
uint8_t rx_buffer[256];
3

4
void ISR(void) {
5
    rx_buffer[rx_pending++] = UART->RDR;
6
    if (rx_pending == 256) signal_task();
7
}
8

9
void task(void) {
10
    for (;;) {
11
        wait_for_signal();
12
        for (int i = 0; i < rx_pending; i++) process(rx_buffer[i]);
13
        rx_pending = 0;
14
    }
15
}

1
/* CAN RX ISR */
2
void CAN_RX_IRQHandler(void) {
3
    can_msg_t msg;
4
    msg.id = CAN->RIR;
5
    msg.dlc = CAN->RDTR & 0xF;
6
    for (int i = 0; i < msg.dlc; i++) msg.data[i] = CAN->RDLR >> (i*8);
7

8
    /* Lock-free push to ring */
9
    can_ring_push(&msg);
10

11
    /* Wake handler task */
12
    BaseType_t pxHP = pdFALSE;
13
    xSemaphoreGiveFromISR(can_sem, &pxHP);
14
    portYIELD_FROM_ISR(pxHP);
15
}

1
typedef struct { uint32_t primask; } critical_section_t;
2

3
static inline critical_section_t critical_enter(void) {
4
    critical_section_t cs;
5
    cs.primask = __get_PRIMASK();
6
    __disable_irq();
7
    return cs;
8
}
9

10
static inline void critical_exit(critical_section_t cs) {
11
    __set_PRIMASK(cs.primask);
12
}
13

14
/* 사용 */
15
{
16
    critical_section_t cs = critical_enter();
17
    shared_var++;
18
    critical_exit(cs);
19
}

1
/* FreeRTOS — kernel critical */
2
__set_BASEPRI(configMAX_SYSCALL_INTERRUPT_PRIORITY << (8 - __NVIC_PRIO_BITS));
3
/* High priority ISR은 통과, kernel·low priority 차단 */
4
critical();
5
__set_BASEPRI(0);

1
ISR: printf("byte: %02X\n", byte);   /* ✗ stack 큼·UART blocking */

1
ISR: void *p = malloc(64);   /* heap lock — deadlock 가능 */

1
ISR: xQueueSend(q, ...);   /* ✗ — block 가능 함수 */

1
void ISR(void) {
2
    process_packet();   /* 1 ms — 다른 IRQ 다 latency */
3
}

1
volatile uint64_t timestamp;
2
ISR: timestamp = read_64();   /* ← Cortex-M에서 *2 store* — split */
3
task: read timestamp           /* ← race */