Mutex 개념 분해 — Ownership·Recursive·Priority Inheritance

1
// 두 task가 같은 자원 (예: SPI bus) 접근
2
void task_a(void *arg) {
3
    while (1) {
4
        spi_write(buf_a, 64);   // 64 byte 전송 — 도중 preempt 시?
5
    }
6
}
7

8
void task_b(void *arg) {
9
    while (1) {
10
        spi_write(buf_b, 64);   // ← task_a 도중 끼어들면 데이터 섞임
11
    }
12
}

1
SemaphoreHandle_t spi_mutex = xSemaphoreCreateMutex();
2

3
void task_a(void *arg) {
4
    while (1) {
5
        xSemaphoreTake(spi_mutex, portMAX_DELAY);
6
        spi_write(buf_a, 64);
7
        xSemaphoreGive(spi_mutex);
8
    }
9
}

1
typedef struct {
2
    int locked;                     // 0=free, 1=locked
3
    Task_t *owner;                  // lock 보유 task
4
    int recursion_count;            // 같은 task의 재진입 횟수
5
    int original_priority;          // owner의 원래 priority (PI 시 복원용)
6
    List_t wait_list;
7
} Mutex_t;

1
SemaphoreHandle_t mtx = xSemaphoreCreateRecursiveMutex();
2

3
void inner(void) {
4
    xSemaphoreTakeRecursive(mtx, portMAX_DELAY);
5
    /* ... */
6
    xSemaphoreGiveRecursive(mtx);
7
}
8

9
void outer(void *arg) {
10
    xSemaphoreTakeRecursive(mtx, portMAX_DELAY);   // count=1
11
    inner();                                          // count=2 → 1
12
    xSemaphoreGiveRecursive(mtx);                    // count=0 → unlock
13
}

1
T_high (priority 5) ←─ semaphore wait (T_low가 보유)
2
T_med  (priority 3) ←─ 실행 중 — T_low를 preempt
3
T_low  (priority 1) ←─ semaphore 보유, preempted
4

5
→ T_high가 *영원히 대기* (T_med이 끝나야 T_low 실행)

1
T_high (priority 5) ←─ mutex wait → T_low의 priority를 5로 boost
2
T_low  (priority 5 임시) ←─ 실행 가능 → mutex 해제
3
T_high 진행

1
void mutex_take(Mutex_t *m, TickType_t timeout) {
2
    portENTER_CRITICAL();
3
    if (m->locked == 0) {
4
        m->locked = 1;
5
        m->owner = current_task;
6
        m->original_priority = current_task->priority;
7
        portEXIT_CRITICAL();
8
        return;
9
    }
10
    // PI — owner의 priority를 자신과 같게 올림
11
    if (current_task->priority > m->owner->priority) {
12
        m->owner->priority = current_task->priority;
13
        rebalance_ready_lists(m->owner);
14
    }
15
    add_to_wait_list(m->wait_list, current_task);
16
    portEXIT_CRITICAL();
17
    block(timeout);
18
}
19

20
void mutex_give(Mutex_t *m) {
21
    portENTER_CRITICAL();
22
    if (current_task != m->owner) {
23
        portEXIT_CRITICAL();
24
        return ERROR_NOT_OWNER;
25
    }
26
    current_task->priority = m->original_priority;  // 복원
27
    if (!list_empty(m->wait_list)) {
28
        Task_t *next = pop_highest(m->wait_list);
29
        m->owner = next;
30
        m->original_priority = next->priority;
31
        wake(next);
32
    } else {
33
        m->locked = 0;
34
        m->owner = NULL;
35
    }
36
    portEXIT_CRITICAL();
37
}

1
// Mutex의 ceiling = 5 (T_high의 priority)
2
T_low가 mutex lock 시 → 즉시 priority를 5로 boost
3
T_med (priority 3)은 *시작도 못 함*

1
// Task A
2
xSemaphoreTake(mutex_X, ...);
3
xSemaphoreTake(mutex_Y, ...);
4

5
// Task B
6
xSemaphoreTake(mutex_Y, ...);
7
xSemaphoreTake(mutex_X, ...);
8

9
// A는 X 보유 후 Y 기다림, B는 Y 보유 후 X 기다림 → 영원

1
if (xSemaphoreTake(mtx, pdMS_TO_TICKS(100)) != pdTRUE) {
2
    log_warning("mutex timeout — possible deadlock");
3
    return ERROR;
4
}

1
// 나쁨
2
xSemaphoreTake(mtx, portMAX_DELAY);
3
log_data();                          // 5 ms (printf 등)
4
xSemaphoreGive(mtx);
5

6
// 좋음 — 자원 접근만 protect
7
xSemaphoreTake(mtx, portMAX_DELAY);
8
data = shared_resource;
9
xSemaphoreGive(mtx);
10
log_data();                          // mutex 밖에서

1
void some_ISR(void) {
2
    xSemaphoreTakeFromISR(mtx, ...);  // ✗ 컴파일 에러 또는 crash
3
}