Deadlock 분석 — 4 조건·Wait-for Graph·Lock Ordering·Timeout

1
SemaphoreHandle_t mtx_A, mtx_B;
2

3
void task1(void *p) {
4
    xSemaphoreTake(mtx_A, portMAX_DELAY);
5
    vTaskDelay(1);   // 짧은 지연
6
    xSemaphoreTake(mtx_B, portMAX_DELAY);   // ← Task2가 잡고 있으면 deadlock
7
    /* ... */
8
}
9

10
void task2(void *p) {
11
    xSemaphoreTake(mtx_B, portMAX_DELAY);
12
    vTaskDelay(1);
13
    xSemaphoreTake(mtx_A, portMAX_DELAY);   // ← Task1이 잡고 있으면 deadlock
14
}

1
       T1 ──── waiting for ────→ T2
2
        ↑                          │
3
        │                       holds
4
       holds              waiting for
5
        │                          ↓
6
       mtx_A    ←── waiting for ── mtx_B

1
/* Convention — 알파벳/주소/ID 기준 */
2
#define MTX_ORDER_A  0
3
#define MTX_ORDER_B  1
4
#define MTX_ORDER_C  2
5

6
void any_task(void) {
7
    /* 항상 A → B → C 순서 */
8
    xSemaphoreTake(mtx_A, ...);
9
    xSemaphoreTake(mtx_B, ...);
10
    xSemaphoreTake(mtx_C, ...);
11
    /* ... */
12
    xSemaphoreGive(mtx_C);
13
    xSemaphoreGive(mtx_B);
14
    xSemaphoreGive(mtx_A);
15
}

1
if (xSemaphoreTake(mtx_A, pdMS_TO_TICKS(100)) != pdPASS) {
2
    log_warning("mtx_A acquire timeout — possible deadlock");
3
    return ERROR_TIMEOUT;
4
}
5
if (xSemaphoreTake(mtx_B, pdMS_TO_TICKS(100)) != pdPASS) {
6
    xSemaphoreGive(mtx_A);   // 보유 자원 release
7
    return ERROR_TIMEOUT;
8
}

1
if (!xSemaphoreTake(mtx_A, 0)) return EBUSY;
2
if (!xSemaphoreTake(mtx_B, 0)) {
3
    xSemaphoreGive(mtx_A);
4
    return EBUSY;
5
}
6
/* both acquired — work */
7
xSemaphoreGive(mtx_B);
8
xSemaphoreGive(mtx_A);

1
bool try_acquire_all(void) {
2
    if (!xSemaphoreTake(mtx_A, 0)) return false;
3
    if (!xSemaphoreTake(mtx_B, 0)) {
4
        xSemaphoreGive(mtx_A);
5
        return false;
6
    }
7
    return true;
8
}
9

10
/* Retry pattern with backoff */
11
while (!try_acquire_all()) {
12
    vTaskDelay(pdMS_TO_TICKS(random_backoff()));
13
}

1
typedef struct {
2
    SemaphoreHandle_t sem;
3
    int level;
4
    const char *name;
5
} hier_mutex_t;
6

7
bool hier_take(hier_mutex_t *m, TickType_t timeout) {
8
    /* TLS 또는 TCB 확장에 현재 task의 보유 level set 보관 */
9
    for (each held lock h) {
10
        if (h.level >= m->level) {
11
            panic("Lock order violation: hold %s (L%d), taking %s (L%d)",
12
                  h.name, h.level, m->name, m->level);
13
        }
14
    }
15
    xSemaphoreTake(m->sem, timeout);
16
    record_held(m);
17
    return true;
18
}

1
rwlock_t rw;
2

3
read_lock(&rw);
4
/* ... */
5
write_lock(&rw);   // ✗ Recursive read-then-write

1
Low task L:  mtx 보유, M에 의해 선점
2
Med task M:  CPU 점유 (mtx 안 씀)
3
High task H: mtx 대기 → L 못 풀고 M이 CPU → unbounded wait

1
/* configUSE_TRACE_FACILITY = 1 */
2
TaskStatus_t arr[20];
3
uxTaskGetSystemState(arr, 20, NULL);
4

5
for (int i = 0; i < N; i++) {
6
    if (arr[i].eCurrentState == eBlocked) {
7
        printf("Task %s blocked on %p\n",
8
               arr[i].pcTaskName, arr[i].xEventListItem);
9
    }
10
}

1
void wd_task(void *p) {
2
    for (;;) {
3
        vTaskDelay(pdMS_TO_TICKS(1000));
4
        if (system_alive_flag == 0) {
5
            log_panic("Possible deadlock — resetting");
6
            HAL_NVIC_SystemReset();
7
        }
8
        system_alive_flag = 0;
9
    }
10
}
11

12
void main_task(void *p) {
13
    for (;;) {
14
        do_work();
15
        system_alive_flag = 1;
16
    }
17
}

1
while (try_take_all() == false) {
2
    release_all();
3
    vTaskDelay(1);   // 양보
4
}

1
vTaskDelay(pdMS_TO_TICKS(rand() % 10));

1
xSemaphoreTake(mtx, portMAX_DELAY);   // ✗ deadlock 감지 불가

1
xSemaphoreTake(mtx, ...);
2
/* ... */
3
xSemaphoreTake(mtx, ...);   // ✗ Self-deadlock (mutex 아닌 binary semaphore)

1
xSemaphoreTake(mtx, ...);
2
some_isr_disable_func();
3
/* ISR 발생 → 같은 mtx 시도 → ✗ */

1
xSemaphoreTake(mtx_A, ...);
2
xQueueReceive(q, &item, portMAX_DELAY);   // ✗ mtx_A 보유 중 무한 대기