Wait/Wound Mutex (데드락 회피 뮤텍스)

여러 뮤텍스(Mutex)를 동시에 획득해야 할 때 데드락을 구조적으로 회피하는 Wait/Wound Mutex를 분석합니다. Wound-Wait와 Wait-Die 두 가지 알고리즘의 원리, ww_mutex/ww_acquire_ctx/ww_class 자료구조, 트랜잭션(Transaction) 티켓 기반 순서 결정, -EDEADLK 재시도 루프, Wound 전파 경로를 추적하고, DRM/GEM/TTM에서의 실전 사용 패턴, 다중 잠금(Lock) 획득 기법, PREEMPT_RT 영향, 안티패턴과 lockdep 디버깅(Debugging)까지 커널 소스 기반으로 포괄합니다.

이론적 배경: 데드락 회피 알고리즘

데드락(deadlock)은 Coffman(1971)이 정의한 네 가지 필요 조건이 동시에 충족될 때 발생합니다: 상호 배제(Mutual Exclusion), 점유와 대기, 비선점(Non-preemptive), 순환 대기. 이 중 하나라도 깨면 데드락을 방지할 수 있습니다.

데드락 대응 전략

ww_mutex는 회피(avoidance) 전략을 구현합니다. 고정된 잠금 순서를 미리 알 수 없는 상황(예: GPU buffer object들을 동적으로 선택하여 잠가야 하는 경우)에서, 트랜잭션의 나이(ticket stamp)를 기준으로 순환 대기 조건을 동적으로 깨뜨립니다.

Wound-Wait 알고리즘 원리

Wound-Wait은 Rosenkrantz 등(1978)이 데이터베이스 동시성 제어를 위해 제안한 알고리즘으로, Linux 커널의 WW_MUTEX_WOUND_WAIT 모드에 구현되어 있습니다. 핵심 규칙은 두 가지입니다:

Wound-Wait의 핵심 성질:

• Starvation-free: 가장 오래된 트랜잭션은 절대 abort되지 않으므로 반드시 완료됩니다.
• Non-preemptive wound: wound 신호를 받아도 보유자는 현재 임계 영역 실행을 마칩니다. 다음 ww_mutex_lock() 호출 시점에서 -EDEADLK를 반환합니다.
• 낮은 abort 빈도: younger가 older를 만나면 wait하므로, 불필요한 재시도가 줄어듭니다.

Wait-Die 알고리즘과 비교

Wait-Die는 Wound-Wait의 대칭 알고리즘입니다. Linux 커널은 WW_MUTEX_WAIT_DIE 모드로 이를 지원합니다.

struct ww_mutex / ww_acquire_ctx / ww_class

ww_mutex 프레임워크는 세 가지 핵심 자료구조로 구성됩니다. include/linux/ww_mutex.h에 정의되어 있습니다.

/* include/linux/ww_mutex.h */

struct ww_class {
    atomic_long_t       stamp;          /* 전역 단조 증가 카운터 */
    struct lock_class_key acquire_key;  /* lockdep: 획득 순서 추적 */
    struct lock_class_key mutex_key;    /* lockdep: 뮤텍스 클래스 */
    const char          *acquire_name; /* lockdep 디버그 이름 */
    const char          *mutex_name;   /* lockdep 디버그 이름 */
    unsigned int         is_wait_die;  /* 0=Wound-Wait, 1=Wait-Die */
};

struct ww_acquire_ctx {
    struct task_struct  *task;          /* 소유 태스크 */
    unsigned long       stamp;         /* 트랜잭션 티켓 번호 */
    unsigned int        acquired;      /* 현재 보유한 잠금 수 */
    unsigned short      wounded;       /* wound 신호 수신 여부 */
    unsigned short      is_wait_die;   /* ww_class에서 복사 */
    #ifdef CONFIG_DEBUG_MUTEXES
    unsigned int        done_acquire;  /* 디버그: 획득 완료 여부 */
    struct ww_class     *ww_class;      /* 디버그: 소속 클래스 */
    struct ww_mutex     *contending_lock; /* 디버그: 경합 중인 잠금 */
    #endif
};

struct ww_mutex {
    struct mutex         base;         /* 기반 mutex */
    struct ww_acquire_ctx *ctx;         /* 현재 보유 컨텍스트 */
    #ifdef CONFIG_DEBUG_MUTEXES
    struct ww_class     *ww_class;      /* 디버그: 소속 클래스 */
    #endif
};

ww_class 초기화 매크로

/* Wound-Wait 모드 (기본, 대부분 사용) */
DEFINE_WW_CLASS(reservation_ww_class);

/* Wait-Die 모드 */
DEFINE_WD_CLASS(my_wd_class);

/* 매크로 확장: */
#define DEFINE_WW_CLASS(classname) \
    struct ww_class classname = { \
        .stamp = ATOMIC_LONG_INIT(0), \
        .acquire_name = #classname "_acquire", \
        .mutex_name = #classname "_mutex", \
        .is_wait_die = 0, \
    }

#define DEFINE_WD_CLASS(classname) \
    struct ww_class classname = { \
        .stamp = ATOMIC_LONG_INIT(0), \
        .acquire_name = #classname "_acquire", \
        .mutex_name = #classname "_mutex", \
        .is_wait_die = 1, \
    }

API 레퍼런스

ww_acquire_ctx: 트랜잭션 컨텍스트

ww_acquire_ctx는 하나의 "트랜잭션"을 나타냅니다. 여러 ww_mutex를 획득하려는 하나의 작업 단위입니다. 초기화 시 ww_class의 전역 카운터에서 ticket stamp를 원자적(Atomic)으로 가져옵니다.

/* kernel/locking/ww_mutex.h 또는 include/linux/ww_mutex.h */

static inline void
ww_acquire_init(struct ww_acquire_ctx *ctx,
                struct ww_class *ww_class)
{
    ctx->task = current;
    ctx->stamp = atomic_long_inc_return_relaxed(&ww_class->stamp);
    ctx->acquired = 0;
    ctx->wounded = 0;
    ctx->is_wait_die = ww_class->is_wait_die;
#ifdef CONFIG_DEBUG_MUTEXES
    ctx->ww_class = ww_class;
    ctx->done_acquire = 0;
    ctx->contending_lock = NULL;
#endif
    /* lockdep: 가상의 acquire lock 등록 */
    mutex_acquire(&ww_class->acquire_key, 0, 0, _RET_IP_);
}

핵심 포인트:

• stamp 값은 단조 증가합니다. 값이 작을수록 오래된(older) 트랜잭션입니다.
• acquired 카운터는 현재 이 컨텍스트가 보유한 ww_mutex 수를 추적합니다.
• wounded 플래그는 다른 (older) 트랜잭션이 이 컨텍스트에게 wound 신호를 보냈는지를 나타냅니다.
• lockdep은 acquire_key를 통해 ww_acquire_ctx 간의 nesting 순서를 검증합니다.

Acquire Ticket 번호와 순서 결정

ww_mutex의 데드락 회피는 ticket stamp의 전체 순서(total order)에 의존합니다. 이 순서가 순환 대기를 방지하는 핵심 메커니즘입니다.

순서 비교 로직:

/* 두 컨텍스트의 나이 비교: stamp가 작은 쪽이 older */
static inline bool __ww_ctx_stamp_after(
    struct ww_acquire_ctx *a,
    struct ww_acquire_ctx *b)
{
    return (signed long)(a->stamp - b->stamp) > 0;
}

/* a가 b보다 나중에 생성됨(younger) → a.stamp > b.stamp */
/* signed 비교로 wrap-around 처리 */

ww_mutex_lock() 흐름 분석

ww_mutex_lock()은 일반 mutex_lock()에 데드락 회피 로직을 추가한 것입니다. 내부적으로 fast path와 slow path로 나뉩니다.

/* ww_mutex_lock 호출 패턴의 전체 흐름 */

struct ww_acquire_ctx ctx;
int ret;

ww_acquire_init(&ctx, &my_ww_class);     /* 1. 트랜잭션 시작 */

retry:
    ret = ww_mutex_lock(&obj_a->lock, &ctx); /* 2. 첫 번째 잠금 */
    if (ret == -EDEADLK)
        goto backoff;

    ret = ww_mutex_lock(&obj_b->lock, &ctx); /* 3. 두 번째 잠금 */
    if (ret == -EDEADLK)
        goto backoff;

    /* 4. 임계 영역: 모든 잠금 획득 상태 */
    do_work(obj_a, obj_b);

    ww_mutex_unlock(&obj_b->lock);
    ww_mutex_unlock(&obj_a->lock);
    ww_acquire_fini(&ctx);                 /* 5. 트랜잭션 종료 */
    return 0;

backoff:
    /* 보유한 잠금을 역순으로 모두 해제 */
    if (ww_mutex_is_locked(&obj_b->lock))
        ww_mutex_unlock(&obj_b->lock);
    if (ww_mutex_is_locked(&obj_a->lock))
        ww_mutex_unlock(&obj_a->lock);

    /* 경합 잠금에 대해 slow path로 대기 */
    ww_mutex_lock_slow(&contending_lock, &ctx);
    goto retry;

상처(Wound) 전파 경로

Wound-Wait 모드에서, older 트랜잭션이 younger 보유자에게 wound 신호를 보내는 과정을 추적합니다. 이 과정은 __ww_mutex_wound() 함수에서 구현됩니다.

/* kernel/locking/ww_mutex.h — wound 전파 핵심 로직 */

static void __ww_mutex_wound(
    struct ww_mutex *lock,
    struct ww_acquire_ctx *wound_ctx,   /* 요청자 (older) */
    struct ww_acquire_ctx *hold_ctx)    /* 보유자 (younger) */
{
    /* hold_ctx가 이미 wounded 상태면 중복 wound 불필요 */
    if (hold_ctx->wounded)
        return;

    /* wounded 플래그 설정 */
    hold_ctx->wounded = 1;

    /* 보유자가 현재 lock의 대기열에서 자고 있다면 깨우기 */
    if (hold_ctx->task != current)
        wake_up_process(hold_ctx->task);
}

경합 처리: -EDEADLK와 재시도 루프

-EDEADLK 반환은 "이 트랜잭션이 양보해야 한다"는 신호입니다. 호출자는 반드시 정해진 프로토콜에 따라 재시도해야 합니다.

재시도 프로토콜

/* 올바른 -EDEADLK 재시도 패턴 */

struct ww_acquire_ctx ctx;
struct ww_mutex *contended = NULL;
int ret;

ww_acquire_init(&ctx, &my_class);

retry:
    /* slow path 진입점: 이전에 경합했던 잠금 먼저 획득 */
    if (contended) {
        ww_mutex_lock_slow(contended, &ctx);
        contended = NULL;
    }

    /* 나머지 잠금 순차 획득 */
    for (i = 0; i < num_objs; i++) {
        ret = ww_mutex_lock(&objs[i]->lock, &ctx);
        if (ret == -EDEADLK) {
            contended = &objs[i]->lock;
            /* 이미 획득한 잠금 모두 해제 */
            while (i--)
                ww_mutex_unlock(&objs[i]->lock);
            goto retry;
        }
    }

    /* 성공: 모든 잠금 획득 상태 */
    do_critical_section(objs, num_objs);

    for (i = num_objs - 1; i >= 0; i--)
        ww_mutex_unlock(&objs[i]->lock);

ww_acquire_fini(&ctx);

-EDEADLK 보장 성질

Slow Path: 대기와 깨우기(Wakeup)

ww_mutex_lock_slow()는 -EDEADLK 후 재시도의 첫 단계입니다. 경합했던 잠금을 무조건 대기(block)하면서 획득합니다. 이 함수는 -EDEADLK를 반환하지 않습니다.

/* ww_mutex_lock_slow — 경합 잠금을 위한 slow path */

void ww_mutex_lock_slow(struct ww_mutex *lock,
                         struct ww_acquire_ctx *ctx)
{
    /* ctx->acquired가 0인지 확인 (모든 잠금이 해제되어야 함) */
    WARN_ON(ctx->acquired > 0);

    /* 무조건 대기: 이 잠금의 보유자보다 우리가 */
    /* older이므로 결국 획득 보장 */
    __ww_mutex_lock(lock, ctx, TASK_UNINTERRUPTIBLE);
}

Slow path가 필요한 이유: 일반 ww_mutex_lock()으로 재시도하면, 이미 wound된 상태에서 또다시 stamp 비교를 하게 됩니다. ww_mutex_lock_slow()는 stamp 비교 없이 무조건 대기하므로, 불필요한 -EDEADLK 순환을 방지합니다.

대기열 순서

ww_mutex의 대기열은 stamp 순서로 정렬됩니다. older 트랜잭션이 먼저 깨어나므로 starvation이 방지됩니다.

/* 대기열 삽입 시 stamp 기반 정렬 위치 결정 */

/* ww_mutex waiter는 mutex waiter를 확장 */
/* list_for_each_entry로 stamp 순서 위치를 찾음 */
list_for_each_entry(cur, &lock->base.wait_list, list) {
    if (__ww_ctx_stamp_after(cur->ww_ctx, ctx->ww_ctx)) {
        /* cur보다 앞에 삽입 (우리가 더 older) */
        list_add_tail(&waiter->list, &cur->list);
        break;
    }
}

GPU/DRM 서브시스템 실전 사용

ww_mutex의 가장 대표적인 사용자는 DRM(Direct Rendering Manager) 서브시스템입니다. GPU 드라이버는 디스플레이 모드 설정, 버퍼(Buffer) 예약 등에서 여러 객체를 동시에 잠가야 하며, 잠금 순서를 미리 결정할 수 없습니다.

drm_modeset_lock

DRM 모드 설정(modeset)에서는 CRTC, 커넥터, 평면(plane) 등 여러 객체의 상태를 원자적으로 변경해야 합니다. 각 객체는 drm_modeset_lock(ww_mutex 기반)으로 보호됩니다.

/* drivers/gpu/drm/drm_modeset_lock.c */

struct drm_modeset_lock {
    struct ww_mutex  mutex;      /* ww_mutex 기반 */
    struct list_head head;       /* 잠금 목록 연결 */
};

/* 전역 ww_class: 모든 modeset lock이 공유 */
DEFINE_WW_CLASS(crtc_ww_class);

/* 모드 설정 잠금 흐름 */
int drm_modeset_lock(struct drm_modeset_lock *lock,
                     struct drm_modeset_acquire_ctx *ctx)
{
    int ret;

    ret = ww_mutex_lock(&lock->mutex, &ctx->ww_ctx);
    if (ret == -EDEADLK) {
        ctx->contended = lock;
        return -EDEADLK;
    }
    if (!ret) {
        list_add(&lock->head, &ctx->locked);
    }
    return ret;
}

GEM Buffer Object 잠금 패턴

GPU 렌더링에서는 여러 GEM(Graphics Execution Manager) 버퍼 오브젝트를 동시에 잠가야 합니다. 각 버퍼의 dma_resv(DMA reservation) 객체가 내부적으로 ww_mutex를 사용합니다.

/* include/linux/dma-resv.h */

struct dma_resv {
    struct ww_mutex       lock;           /* ww_mutex! */
    struct dma_resv_list  *fences;        /* 공유/배타 펜스 목록 */
};

/* 전역 ww_class: 모든 dma_resv가 공유 */
extern struct ww_class reservation_ww_class;

/* GEM 버퍼 여러 개를 동시에 잠그는 패턴 (drm_exec) */
struct drm_exec exec;
drm_exec_init(&exec, DRM_EXEC_INTERRUPTIBLE_WAIT, 0);
drm_exec_until_all_locked(&exec) {
    ret = drm_exec_prepare_obj(&exec, &bo_a->base, 1);
    drm_exec_retry_on_contention(&exec);

    ret = drm_exec_prepare_obj(&exec, &bo_b->base, 1);
    drm_exec_retry_on_contention(&exec);
}

/* 임계 영역: 모든 BO 잠금 보유 */
submit_rendering(bo_a, bo_b);

drm_exec_fini(&exec);    /* 모든 잠금 해제 */

TTM 메모리 관리자 잠금

TTM(Translation Table Manager)은 GPU 메모리 관리 레이어로, 버퍼 오브젝트의 배치(placement)와 이동(migration)을 관리합니다. TTM은 dma_resv의 ww_mutex를 통해 버퍼 잠금을 구현합니다.

/* drivers/gpu/drm/ttm/ttm_bo.c */

/* TTM 버퍼 잠금: dma_resv.lock (ww_mutex) 사용 */
int ttm_bo_reserve(struct ttm_buffer_object *bo,
                   bool interruptible,
                   bool no_wait,
                   struct ww_acquire_ctx *ticket)
{
    int ret;

    if (no_wait) {
        if (!ww_mutex_trylock(&bo->base.resv->lock, ticket))
            return -EBUSY;
    } else if (interruptible) {
        ret = ww_mutex_lock_interruptible(
                  &bo->base.resv->lock, ticket);
    } else {
        ret = ww_mutex_lock(
                  &bo->base.resv->lock, ticket);
    }

    return ret;
}

/* TTM eviction: 여러 BO를 잠가야 할 때 ww_mutex 재시도 */
int ttm_bo_evict_first(struct ttm_device *bdev,
                       struct ttm_resource_manager *man,
                       struct ww_acquire_ctx *ticket)
{
    /* LRU에서 BO 선택 후 ttm_bo_reserve() */
    /* -EDEADLK 시 호출자의 재시도 루프로 전파 */
}

다중 잠금 획득 패턴

여러 ww_mutex를 획득하는 정규 패턴은 크게 두 가지입니다: 순차 획득 + 재시도와 정렬 후 획득.

패턴 1: 순차 획득 + -EDEADLK 재시도

/* 가장 일반적인 패턴: 순서 없이 획득, -EDEADLK 시 backoff */

struct ww_acquire_ctx ctx;
struct ww_mutex *contended = NULL;

ww_acquire_init(&ctx, &my_class);

retry:
    if (contended) {
        ww_mutex_lock_slow(contended, &ctx);
        contended = NULL;
    }

    for (i = 0; i < n; i++) {
        if (&locks[i] == contended)
            continue;  /* slow path에서 이미 획득 */

        ret = ww_mutex_lock(&locks[i], &ctx);
        if (ret == -EDEADLK) {
            contended = &locks[i];
            while (i--)
                ww_mutex_unlock(&locks[i]);
            goto retry;
        }
    }

    /* 성공 */
    critical_section();

    for (i = n - 1; i >= 0; i--)
        ww_mutex_unlock(&locks[i]);
ww_acquire_fini(&ctx);

패턴 2: 주소 정렬 후 획득 (ww_mutex 불필요)

/* 잠글 객체가 미리 알려진 경우: 주소 순서로 획득하면 데드락 없음 */
/* 이 경우 일반 mutex로도 충분 */

if (&a->lock < &b->lock) {
    mutex_lock(&a->lock);
    mutex_lock(&b->lock);
} else {
    mutex_lock(&b->lock);
    mutex_lock(&a->lock);
}

/* ww_mutex는 잠금 대상이 동적으로 결정되어
   주소 정렬이 불가능한 경우에 사용 */

PREEMPT_RT 영향

CONFIG_PREEMPT_RT에서 일반 mutex_t는 rt_mutex 기반의 sleeping lock으로 변환됩니다. ww_mutex도 이 변환의 영향을 받습니다.

/* PREEMPT_RT에서의 ww_mutex 내부 구조 변화 */

#ifdef CONFIG_PREEMPT_RT
struct mutex {
    struct rt_mutex_base  rtmutex;   /* rt_mutex 기반! */
    /* PI: rb-tree 대기열, priority boosting */
};
#else
struct mutex {
    atomic_long_t        owner;     /* CAS 기반 fast path */
    struct optimistic_spin_queue osq; /* MCS 기반 spinning */
    struct list_head      wait_list;
};
#endif

/* ww_mutex는 어느 경우든 struct mutex를 내장하므로
   PREEMPT_RT 시 자동으로 rt_mutex 기반으로 전환 */

실전 사용 패턴

패턴: DRM Atomic Commit

/* DRM atomic commit의 전형적인 ww_mutex 사용 */

int drm_atomic_commit(struct drm_atomic_state *state)
{
    struct drm_modeset_acquire_ctx *ctx = state->acquire_ctx;
    int ret;

retry:
    /* 필요한 CRTC, connector, plane 잠금 */
    drm_for_each_crtc_in_state(state, crtc, crtc_state, i) {
        ret = drm_modeset_lock(&crtc->mutex, ctx);
        if (ret)
            goto fail;
    }

    /* ... connector, plane 잠금 ... */

    ret = drm_atomic_check_only(state);
    if (!ret)
        ret = drm_atomic_helper_commit(state);

fail:
    if (ret == -EDEADLK) {
        drm_modeset_backoff(ctx);   /* 모든 잠금 해제 + slow path */
        goto retry;
    }
    return ret;
}

패턴: dma_resv 다중 버퍼 잠금

/* GPU command submission: 여러 BO를 동시에 잠금 */

struct drm_exec exec;
drm_exec_init(&exec, DRM_EXEC_INTERRUPTIBLE_WAIT, 0);

drm_exec_until_all_locked(&exec) {
    /* 각 BO의 dma_resv.lock (ww_mutex) 획득 */
    drm_exec_prepare_array(&exec, objs, num_objs, 1);
    /* 내부적으로 -EDEADLK 재시도 자동 처리 */
}

/* 모든 BO 잠금 보유: 펜스 추가, 렌더링 제출 */
for (i = 0; i < num_objs; i++)
    dma_resv_add_fence(objs[i]->resv, fence, usage);

drm_exec_fini(&exec);

패턴: i915 GEM Execbuffer

/* drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c */

/* i915 execbuffer: ww_mutex로 버퍼 오브젝트 잠금 */
static int eb_reserve(struct i915_execbuffer *eb)
{
    struct ww_acquire_ctx *ctx = &eb->ww;

    /* 모든 BO에 대해 dma_resv_lock(ww_mutex_lock) */
    for (i = 0; i < eb->buffer_count; i++) {
        struct i915_vma *vma = eb->vma[i];
        ret = i915_gem_object_lock(vma->obj, ctx);
        if (ret == -EDEADLK)
            return ret;   /* 호출자가 재시도 */
    }
    return 0;
}

안티패턴

안티패턴 1: -EDEADLK 시 잠금 해제 누락

/* 잘못된 코드: 이미 획득한 잠금을 해제하지 않고 재시도 */

ret = ww_mutex_lock(&a, &ctx);
ret = ww_mutex_lock(&b, &ctx);
if (ret == -EDEADLK) {
    /* BUG: a를 해제하지 않고 slow path 진입! */
    ww_mutex_lock_slow(&b, &ctx);  /* ctx->acquired > 0 → WARN */
}

안티패턴 2: 재시도 시 ctx 재초기화

/* 잘못된 코드: 재시도 때 새 stamp를 받으면
   younger가 되어 livelock 가능 */

retry:
    ww_acquire_init(&ctx, &my_class);  /* BUG: 매번 새 stamp! */
    ret = ww_mutex_lock(&a, &ctx);
    if (ret == -EDEADLK) {
        ww_acquire_fini(&ctx);
        goto retry;  /* 새 stamp → 항상 youngest → 항상 양보 */
    }

안티패턴 3: ww_mutex_lock_slow 대신 ww_mutex_lock 사용

/* 잘못된 코드: 경합 잠금에 일반 lock 사용 */

retry:
    if (contended) {
        /* BUG: lock_slow 대신 lock 사용 → 또 -EDEADLK 가능 */
        ret = ww_mutex_lock(contended, &ctx);
        /* 올바른: ww_mutex_lock_slow(contended, &ctx); */
    }

안티패턴 4: 서로 다른 ww_class의 mutex 혼합

/* 잘못된 코드: 다른 class의 mutex를 같은 ctx로 잠금 */

DEFINE_WW_CLASS(class_a);
DEFINE_WW_CLASS(class_b);

ww_acquire_init(&ctx, &class_a);
ww_mutex_lock(&lock_of_class_b, &ctx);  /* BUG: class 불일치! */
/* lockdep이 이를 감지하여 경고 출력 */

디버깅과 lockdep

ww_mutex는 lockdep과 밀접하게 통합되어, 잘못된 사용 패턴을 런타임에 감지합니다.

lockdep이 감지하는 ww_mutex 오류

디버그 관련 설정

ww_mutex 전용 디버그 옵션은 CONFIG_DEBUG_WW_MUTEX_SLOWPATH=y (slow path 강제 진입으로 경합 시뮬레이션)입니다. CONFIG_PROVE_LOCKING, CONFIG_LOCK_STAT, CONFIG_DEBUG_LOCK_ALLOC 등 공통 잠금 디버깅 옵션은 lockdep — 커널 설정을 참고하세요.

lock_stat으로 경합 분석

CONFIG_LOCK_STAT=y 활성화 후 grep ww_mutex /proc/lock_stat으로 ww_class별 경합 통계(con-bounces, contentions, waittime)를 확인할 수 있습니다. /proc/lock_stat 필드 설명과 상세 사용법은 lockdep의 /proc/lock_stat 섹션을 참고하세요.

커널 설정

셀프 테스트

# ww_mutex 셀프 테스트 실행
modprobe test-ww_mutex

# 결과 확인
dmesg | grep -i ww_mutex

# 출력 예시:
# test_ww_mutex: ww_mutex test cases passed
# test_ww_mutex: stress test (Wound-Wait): passed
# test_ww_mutex: stress test (Wait-Die): passed

ww_mutex_lock() 소스 코드 완전 분석

ww_mutex_lock()의 실제 구현은 kernel/locking/ww_mutex.h에 있으며, 일반 mutex의 fast path와 ww_mutex 고유의 context 설정, stamp 비교, slowpath 진입이 결합된 복잡한 구조입니다. 단계별로 소스 코드를 추적합니다.

진입점(Entry Point): ww_mutex_lock

/* include/linux/ww_mutex.h */

static inline int
ww_mutex_lock(struct ww_mutex *lock,
              struct ww_acquire_ctx *ctx)
{
    /* ctx가 NULL이면 일반 mutex_lock과 동일 */
    if (ctx)
        return __ww_mutex_lock(lock, ctx, TASK_UNINTERRUPTIBLE);

    mutex_lock(&lock->base);
    return 0;
}

__ww_mutex_lock 구현

/* kernel/locking/mutex.c — __ww_mutex_lock 핵심 */

static int __sched
__ww_mutex_lock(struct ww_mutex *lock,
                struct ww_acquire_ctx *ctx,
                unsigned int state)
{
    int ret;

    might_sleep();

    /* Fast path: 뮤텍스가 비어있으면 CAS로 즉시 획득 */
    if (__mutex_trylock_fast(&lock->base)) {
        /* fast path 성공: ctx를 lock에 연결 */
        ww_mutex_set_context_fastpath(lock, ctx);
        return 0;
    }

    /* Slow path: 경합 발생, 대기열 진입 */
    ret = __ww_mutex_lock_slowpath(lock, ctx, state);
    return ret;
}

ww_mutex_set_context_fastpath

/* kernel/locking/ww_mutex.h */

static inline void
ww_mutex_set_context_fastpath(struct ww_mutex *lock,
                              struct ww_acquire_ctx *ctx)
{
    /* lock->ctx 설정 (보유 컨텍스트 등록) */
    WRITE_ONCE(lock->ctx, ctx);

    /* 중요: smp_mb()로 ctx 설정이 다른 CPU에 가시적이게 */
    /* 다른 CPU의 waiter가 stamp 비교를 올바르게 할 수 있도록 */
    smp_mb__after_atomic();

    ctx->acquired++;

    /* 대기열에 older waiter가 있으면 wound 처리 필요 */
    if (unlikely(!list_empty(&lock->base.wait_list)))
        __ww_mutex_check_waiters(lock, ctx);
}

slowpath 진입과 stamp 비교

/* kernel/locking/ww_mutex.h — slowpath 핵심 로직 */

static int
__ww_mutex_lock_slowpath(struct ww_mutex *lock,
                         struct ww_acquire_ctx *ctx,
                         unsigned int state)
{
    struct mutex_waiter waiter;
    struct ww_acquire_ctx *hold_ctx;
    int ret = 0;

    raw_spin_lock(&lock->base.wait_lock);

    /* 보유자의 ctx 읽기 */
    hold_ctx = READ_ONCE(lock->ctx);

    /* ctx가 없으면 = 일반 mutex 경합, 단순 대기 */
    if (!hold_ctx) {
        __ww_mutex_add_waiter(&waiter, lock, ctx);
        goto wait;
    }

    /* 동일 ctx인지 검사 → -EALREADY (이중 잠금) */
    if (hold_ctx == ctx) {
        ret = -EALREADY;
        goto out;
    }

    /* 핵심: stamp 비교 */
    if (__ww_ctx_stamp_after(ctx, hold_ctx)) {
        /* 우리(ctx)가 younger */
        if (ctx->is_wait_die) {
            /* Wait-Die: younger는 즉시 die */
            ret = -EDEADLK;
            goto out;
        }
        /* Wound-Wait: younger는 wait (대기열 삽입) */
        __ww_mutex_add_waiter(&waiter, lock, ctx);
    } else {
        /* 우리(ctx)가 older → 보유자를 wound */
        __ww_mutex_wound(lock, ctx, hold_ctx);
        __ww_mutex_add_waiter(&waiter, lock, ctx);
    }

wait:
    /* 대기 루프: schedule() 반복 */
    for (;;) {
        if (__mutex_trylock(&lock->base))
            break;

        /* wounded 상태 검사 */
        if (ctx->wounded) {
            ret = -EDEADLK;
            break;
        }

        set_current_state(state);
        raw_spin_unlock(&lock->base.wait_lock);
        schedule();
        raw_spin_lock(&lock->base.wait_lock);
    }

out:
    raw_spin_unlock(&lock->base.wait_lock);
    return ret;
}

Wound 전파 소스 분석

__ww_mutex_wound()는 ww_mutex의 핵심 메커니즘입니다. older 요청자가 younger 보유자에게 양보를 요청하는 과정의 모든 경로를 소스 레벨에서 분석합니다.

wound 감지와 wounded 플래그

/* kernel/locking/ww_mutex.h — __ww_mutex_wound 전체 구현 */

static void
__ww_mutex_wound(struct ww_mutex *lock,
                  struct ww_acquire_ctx *wound_ctx,  /* older 요청자 */
                  struct ww_acquire_ctx *hold_ctx)   /* younger 보유자 */
{
    /* 1단계: Wait-Die 모드에서는 wound 불가 */
    if (hold_ctx->is_wait_die)
        return;

    /* 2단계: 이미 wounded 상태면 중복 wound 방지 */
    if (hold_ctx->wounded)
        return;

    /* 3단계: stamp 재확인 (race condition 방어) */
    /* wound_ctx가 hold_ctx보다 정말 older인지 */
    if (__ww_ctx_stamp_after(wound_ctx, hold_ctx))
        return;  /* 아닌 경우: wound 하지 않음 */

    /* 4단계: wounded 플래그 설정 */
    hold_ctx->wounded = 1;

    /* 5단계: 보유자가 다른 ww_mutex의 대기열에서 */
    /*   자고 있을 수 있음 → 깨워서 -EDEADLK 확인하게 함 */
    if (hold_ctx->task != current)
        wake_up_process(hold_ctx->task);
}

wounded waiter의 깨어남 경로

wound 신호를 받은 보유자가 실제로 -EDEADLK를 반환하는 경로는 두 가지입니다:

/* 경로 1: 보유자가 다른 ww_mutex 대기열에서 sleeping */
/* → wake_up_process()로 깨어남 */
/* → 대기 루프에서 wounded 플래그 검사 */

for (;;) {
    if (__mutex_trylock(&lock->base))
        break;

    /* ← wounded 검사: 여기서 -EDEADLK 반환 */
    if (ctx->wounded) {
        ret = -EDEADLK;
        break;
    }

    schedule();
}

/* 경로 2: 보유자가 현재 임계 영역에서 실행 중 */
/* → 다음 ww_mutex_lock() 호출 시 ctx->wounded 검사 */
/* → 보유자의 다음 잠금 시도에서 -EDEADLK */

-EDEADLK 반환 후 정리

/* -EDEADLK 반환 시 waiter 정리 */

if (ret == -EDEADLK) {
    /* 대기열에서 waiter 제거 */
    __mutex_remove_waiter(&lock->base, &waiter);

    /* wounded 플래그는 유지 — 호출자가 모든 잠금 해제 후 */
    /* ww_mutex_lock_slow()에서 cleared */

    /* contending_lock 설정 (디버그 모드) */
#ifdef CONFIG_DEBUG_MUTEXES
    ctx->contending_lock = lock;
#endif
}

ww_mutex_unlock() 소스 분석

ww_mutex_unlock()은 일반 mutex_unlock에 ww_acquire_ctx 정리를 추가한 것입니다. 해제 시 ctx 연결 해제와 acquired 카운터 감소가 핵심입니다.

ww_mutex_unlock 구현

/* include/linux/ww_mutex.h */

static inline void
ww_mutex_unlock(struct ww_mutex *lock)
{
    struct ww_acquire_ctx *ctx = lock->ctx;

    /* 1단계: ctx가 있으면 정리 */
    if (ctx) {
#ifdef CONFIG_DEBUG_MUTEXES
        /* 디버그: lock의 ww_class와 ctx의 ww_class 일치 확인 */
        DEBUG_LOCKS_WARN_ON(lock->ww_class != ctx->ww_class);
#endif
        /* acquired 카운터 감소 */
        ctx->acquired--;

        /* lock->ctx 연결 해제 */
        WRITE_ONCE(lock->ctx, NULL);
    }

    /* 2단계: 기반 mutex 해제 (대기자 깨우기 포함) */
    mutex_unlock(&lock->base);
}

대기자 깨우기 메커니즘

/* mutex_unlock 내부의 대기자 깨우기 */

static void
__mutex_unlock_slowpath(struct mutex *lock)
{
    struct mutex_waiter *waiter;

    raw_spin_lock(&lock->wait_lock);

    /* 대기열의 첫 번째 waiter 선택 */
    /* ww_mutex의 경우 stamp 순서로 정렬되어 있으므로 */
    /* 가장 older한 waiter가 먼저 선택됨 */
    waiter = list_first_entry(&lock->wait_list,
                              struct mutex_waiter, list);

    wake_up_process(waiter->task);
    raw_spin_unlock(&lock->wait_lock);
}

컨텍스트 정리 순서

아키텍처별 원자적 연산(Atomic Operation)

ww_mutex의 fast path는 cmpxchg(Compare-And-Exchange)에 의존하며, stamp 발급은 atomic_long_inc_return을 사용합니다. 이러한 원자적 연산은 아키텍처마다 구현이 다릅니다.

fast path의 cmpxchg

/* kernel/locking/mutex.c — __mutex_trylock_fast */

static inline bool
__mutex_trylock_fast(struct mutex *lock)
{
    unsigned long zero = 0;

    /* owner가 0(unlocked)이면 current로 교체 */
    if (atomic_long_try_cmpxchg_acquire(
            &lock->owner, &zero,
            (unsigned long)current))
        return true;

    return false;
}

x86: LOCK CMPXCHG

; x86에서 atomic_long_try_cmpxchg_acquire 구현
; ACQUIRE semantics = LOCK prefix (x86은 TSO이므로 추가 배리어 불필요)

lock cmpxchg [rdi], rsi     ; atomic CAS: if (*rdi == rax) *rdi = rsi
                             ; ZF set on success
setz al                      ; return ZF (성공 여부)

; LOCK prefix는 x86에서 full memory barrier를 의미
; 따라서 별도의 acquire fence가 불필요

ARM64: LDAXR/STXR (LSE: CAS)

// ARM64에서 cmpxchg — 두 가지 구현

// (1) LL/SC 기반 (ARMv8.0)
1: ldaxr   x2, [x0]          // Load-Acquire Exclusive
   cmp     x2, x3             // expected 값과 비교
   b.ne    2f                 // 불일치 → 실패
   stxr    w4, x1, [x0]       // Store Exclusive (acquire는 load에서)
   cbnz    w4, 1b             // store 실패 → 재시도
2:

// (2) LSE 확장 (ARMv8.1+, 더 효율적)
   cas     x3, x1, [x0]       // Compare-And-Swap (단일 명령어)
   // x3 = expected, x1 = desired, [x0] = target
   // casa (acquire), casal (acquire+release) 변형 존재

stamp 발급: atomic_long_inc_return

/* ww_acquire_init에서의 stamp 발급 */
ctx->stamp = atomic_long_inc_return_relaxed(&ww_class->stamp);

/* _relaxed: 순서 보장 불필요 (stamp 값만 유일하면 됨) */
/*   x86: lock xadd (항상 full barrier) */
/*   ARM64: ldxr/stxr 루프 또는 ldadd (LSE) */
/*   RISC-V: amoadd.w (relaxed ordering) */

아키텍처별 원자적 연산 비교

벤치마크: ww_mutex 경합 시나리오

ww_mutex의 실제 성능은 경합 빈도, 잠금 수, 알고리즘 선택에 따라 크게 달라집니다. 커널의 test-ww_mutex 셀프 테스트와 DRM 워크로드 기반 벤치마크 결과를 분석합니다.

재시도 오버헤드(Overhead) 분석

/* ww_mutex 벤치마크 시나리오 */

/* 시나리오 1: 2 스레드, 2 잠금 — 최소 경합 */
/* 시나리오 2: 4 스레드, 4 잠금 — 중간 경합 */
/* 시나리오 3: 8 스레드, 16 잠금 — 높은 경합 */
/* 시나리오 4: 16 스레드, 32 잠금 — 극심한 경합 */

/* 측정 항목: */
/*   - 잠금 획득 완료까지 평균 시간 (ns) */
/*   - -EDEADLK 발생 횟수 / 전체 시도 */
/*   - 최대 재시도 깊이 */

DRM 워크로드 영향

# DRM atomic commit에서의 ww_mutex 경합 측정
# perf lock을 사용한 실제 워크로드 프로파일링

perf lock record -- glmark2 --run-forever &
sleep 30 && kill %1
perf lock report --sort acquired,contended,wait_total

# 출력 예시 (4K 듀얼 모니터, AMD GPU):
#                    Name   acquired  contended  wait total
# reservation_ww_class     48231       1247       3.2 ms
# crtc_ww_class             892         34       0.1 ms

메모리 순서와 ww_mutex

ww_mutex는 일반 mutex의 ACQUIRE/RELEASE 의미론 위에 stamp 가시성과 wounded 플래그 순서 보장(Ordering)이 추가됩니다. 이러한 메모리 순서 보장이 ww_mutex의 정확성(correctness)에 필수적입니다.

ACQUIRE/RELEASE 기본 의미론

/* ww_mutex의 ACQUIRE/RELEASE 경계 */

/* ACQUIRE: ww_mutex_lock 성공 시 */
/* - 잠금 이후의 모든 메모리 접근이 잠금 획득 이전으로 재배치되지 않음 */
/* - lock->ctx 설정이 다른 CPU에서 가시적 */

/* RELEASE: ww_mutex_unlock 시 */
/* - 임계 영역의 모든 메모리 접근이 잠금 해제 이후로 재배치되지 않음 */
/* - lock->ctx = NULL이 다른 CPU에서 즉시 가시적 */

/* fast path CAS가 ACQUIRE semantics를 제공: */
atomic_long_try_cmpxchg_acquire(&lock->owner, ...);
/*                     ^^^^^^^ */
/* _acquire 접미사 = load 이후 명령이 앞으로 재배치 불가 */

stamp 가시성 보장

/* ww_mutex_set_context_fastpath에서의 배리어 */

WRITE_ONCE(lock->ctx, ctx);    /* (a) ctx 포인터 설정 */

/* smp_mb 필요 이유: */
/* 다른 CPU의 waiter가 lock->ctx를 읽고 */
/* ctx->stamp를 참조할 때 */
/* (a)가 (b) 이전에 가시적이어야 함 */
smp_mb__after_atomic();         /* full memory barrier */

/* 다른 CPU: */
hold_ctx = READ_ONCE(lock->ctx); /* lock->ctx 읽기 */
if (hold_ctx)
    __ww_ctx_stamp_after(ctx, hold_ctx);
    /* hold_ctx->stamp 접근: (a) 이후 가시적이어야 */

wounded 플래그 순서 보장

/* wound 전파에서의 메모리 순서 */

/* CPU 0 (older 요청자): */
hold_ctx->wounded = 1;        /* (1) wounded 설정 */
/* wait_lock spinlock이 RELEASE barrier 제공 */
wake_up_process(hold_ctx->task); /* (2) 깨우기 */

/* CPU 1 (younger 보유자, 깨어난 후): */
/* schedule() 복귀 시 ACQUIRE barrier 내재 */
if (ctx->wounded)            /* (3) wounded 읽기 */
    ret = -EDEADLK;

/* (1) → smp_mb (spinlock release) → (2) → schedule barrier → (3) */
/* 따라서 (3)에서 wounded=1이 반드시 가시적 */

DRM Modeset Lock 소스 추적

DRM atomic modeset은 ww_mutex의 가장 정교한 사용자입니다. drm_modeset_lock, drm_modeset_acquire_ctx, drm_modeset_backoff의 전체 소스 경로를 추적합니다.

drm_modeset_acquire_ctx 초기화

/* drivers/gpu/drm/drm_modeset_lock.c */

void drm_modeset_acquire_init(
    struct drm_modeset_acquire_ctx *ctx,
    uint32_t flags)
{
    /* ww_acquire_ctx 초기화: stamp 할당 */
    ww_acquire_init(&ctx->ww_ctx, &crtc_ww_class);

    /* 잠금 목록 초기화 */
    INIT_LIST_HEAD(&ctx->locked);

    /* 경합 잠금 추적 */
    ctx->contended = NULL;
    ctx->trylock_only = 0;

    if (flags & DRM_MODESET_ACQUIRE_INTERRUPTIBLE)
        ctx->interruptible = 1;
}

drm_modeset_lock 구현

/* drm_modeset_lock — ww_mutex_lock 래퍼 */

int drm_modeset_lock(struct drm_modeset_lock *lock,
                     struct drm_modeset_acquire_ctx *ctx)
{
    int ret;

    /* trylock_only 모드: 대기 없이 시도 */
    if (ctx->trylock_only) {
        if (!ww_mutex_trylock(&lock->mutex,
                              &ctx->ww_ctx))
            return -EBUSY;
        goto locked;
    }

    /* interruptible 또는 일반 잠금 */
    if (ctx->interruptible)
        ret = ww_mutex_lock_interruptible(
                  &lock->mutex, &ctx->ww_ctx);
    else
        ret = ww_mutex_lock(
                  &lock->mutex, &ctx->ww_ctx);

    if (ret == -EDEADLK) {
        /* 경합 잠금 기록: backoff에서 사용 */
        ctx->contended = lock;
        return -EDEADLK;
    }
    if (ret)
        return ret;

locked:
    /* 잠금 목록에 추가 (나중에 일괄 해제용) */
    list_add(&lock->head, &ctx->locked);
    return 0;
}

drm_modeset_backoff: 재시도 핵심

/* drm_modeset_backoff — -EDEADLK 후 자동 재시도 */

int drm_modeset_backoff(
    struct drm_modeset_acquire_ctx *ctx)
{
    struct drm_modeset_lock *contended = ctx->contended;

    /* 1단계: 보유한 모든 잠금 해제 */
    drm_modeset_drop_locks(ctx);

    /* 2단계: wounded 플래그 클리어 */
    ctx->contended = NULL;

    /* 3단계: 경합 잠금에 slow path로 대기 */
    if (ctx->interruptible)
        return ww_mutex_lock_slow_interruptible(
                   &contended->mutex, &ctx->ww_ctx);

    ww_mutex_lock_slow(&contended->mutex,
                        &ctx->ww_ctx);

    /* 경합 잠금을 잠금 목록에 추가 */
    list_add(&contended->head, &ctx->locked);

    return 0;
}

drm_modeset_lock_all: 전역 잠금

/* 모든 modeset 객체를 한 번에 잠금 (legacy path) */

int drm_modeset_lock_all_ctx(
    struct drm_device *dev,
    struct drm_modeset_acquire_ctx *ctx)
{
    int ret;

    /* mode_config.connection_mutex 잠금 */
    ret = drm_modeset_lock(&dev->mode_config.connection_mutex, ctx);
    if (ret)
        return ret;

    /* 모든 CRTC 잠금 */
    drm_for_each_crtc(crtc, dev) {
        ret = drm_modeset_lock(&crtc->mutex, ctx);
        if (ret)
            return ret;
    }

    /* 모든 Plane 잠금 */
    drm_for_each_plane(plane, dev) {
        ret = drm_modeset_lock(&plane->mutex, ctx);
        if (ret)
            return ret;
    }

    return 0;
}

dma_resv 심층: GEM/TTM 버퍼 예약

dma_resv(DMA reservation)는 GPU 버퍼 오브젝트의 동기화 핵심입니다. 내부 ww_mutex로 다중 버퍼 잠금을 구현하고, DMA fence로 GPU 작업 간 의존성을 관리합니다.

dma_resv 구조체(Struct) 심층

/* include/linux/dma-resv.h */

struct dma_resv {
    struct ww_mutex       lock;      /* ww_mutex! */
    struct dma_resv_list  *fences;   /* RCU-protected fence list */
};

/* 전역 ww_class */
DEFINE_WW_CLASS(reservation_ww_class);

struct dma_resv_list {
    struct rcu_head       rcu;
    u32                  num_fences;
    u32                  max_fences;
    struct dma_fence      *table[];  /* flexible array */
};

dma_resv_lock API

/* dma_resv_lock — 버퍼 예약 잠금 */

static inline int
dma_resv_lock(struct dma_resv *obj,
              struct ww_acquire_ctx *ctx)
{
    return ww_mutex_lock(&obj->lock, ctx);
}

static inline int
dma_resv_lock_interruptible(struct dma_resv *obj,
                            struct ww_acquire_ctx *ctx)
{
    return ww_mutex_lock_interruptible(&obj->lock, ctx);
}

static inline void
dma_resv_lock_slow(struct dma_resv *obj,
                    struct ww_acquire_ctx *ctx)
{
    ww_mutex_lock_slow(&obj->lock, ctx);
}

static inline void
dma_resv_unlock(struct dma_resv *obj)
{
    ww_mutex_unlock(&obj->lock);
}

공유/배타 펜스 관리

/* dma_resv에 펜스 추가 — ww_mutex 보유 상태에서만 */

void dma_resv_add_fence(struct dma_resv *obj,
                        struct dma_fence *fence,
                        enum dma_resv_usage usage)
{
    /* lock이 보유 상태인지 확인 */
    dma_resv_assert_held(obj);

    /* usage 종류: */
    /* DMA_RESV_USAGE_WRITE — 배타적 쓰기 */
    /* DMA_RESV_USAGE_READ  — 공유 읽기 */
    /* DMA_RESV_USAGE_BOOKKEEP — 관리용 */

    /* fence list에 RCU-safe 추가 */
    dma_resv_list_add(obj, fence, usage);
}

implicit synchronization

/* implicit sync: 버퍼에 대한 GPU 작업 순서 보장 */

/* 1. 이전 GPU 작업의 fence를 읽기 */
dma_resv_for_each_fence(&cursor, obj,
                         DMA_RESV_USAGE_WRITE, fence) {
    /* 이전 write fence가 완료될 때까지 대기 */
    dma_fence_wait(fence, interruptible);
}

/* 2. 새 작업의 fence 추가 */
dma_resv_add_fence(obj, new_fence, DMA_RESV_USAGE_WRITE);

/* ww_mutex가 보장하는 것: */
/* - fence list 수정의 원자성 */
/* - 다중 버퍼 간 fence 추가의 일관성 */
/* - 데드락 없는 다중 버퍼 동시 잠금 */

drm_exec: 현대적 다중 잠금 래퍼

drm_exec는 Linux 6.4에서 도입된 ww_mutex 다중 잠금 헬퍼입니다. -EDEADLK 재시도 루프를 자동화하여 GPU 드라이버 코드를 크게 단순화합니다. 기존 drm_gem_lock_reservations()를 대체합니다.

drm_exec 구조체

/* include/drm/drm_exec.h */

struct drm_exec {
    struct ww_acquire_ctx  ticket;    /* ww_acquire_ctx */
    uint32_t              flags;     /* DRM_EXEC_* 플래그 */
    uint32_t              num_objects;/* 잠금 대상 객체 수 */
    uint32_t              max_objects;/* 할당 크기 */
    struct drm_gem_object **objects;  /* 잠금 객체 배열 */
    struct drm_gem_object *contended; /* 경합 객체 */
    unsigned int          prelocked; /* slow path 잠금 수 */
};

drm_exec 핵심 API

/* drm_exec 사용 패턴 */

/* 1. 초기화 */
void drm_exec_init(struct drm_exec *exec,
                    uint32_t flags,
                    unsigned nr);
/* flags: DRM_EXEC_INTERRUPTIBLE_WAIT — 인터럽트 가능 대기 */
/*        DRM_EXEC_IGNORE_DUPLICATES — 중복 객체 무시 */
/* nr: 예상 객체 수 (사전 할당용) */

/* 2. 객체 잠금 (자동 재시도) */
int drm_exec_prepare_obj(struct drm_exec *exec,
                         struct drm_gem_object *obj,
                         unsigned int num_fences);

/* 3. 배열 일괄 잠금 */
int drm_exec_prepare_array(struct drm_exec *exec,
                           struct drm_gem_object **objects,
                           unsigned int num_objects,
                           unsigned int num_fences);

/* 4. 정리: 모든 잠금 해제 */
void drm_exec_fini(struct drm_exec *exec);

자동 재시도 매크로

/* drm_exec의 핵심: 자동 재시도 매크로 */

#define drm_exec_until_all_locked(exec) \
    while (drm_exec_cleanup(exec))

#define drm_exec_retry_on_contention(exec) \
    do { \
        if (unlikely((exec)->contended)) \
            continue; \
    } while (0)

/* drm_exec_cleanup 내부: */
static inline bool
drm_exec_cleanup(struct drm_exec *exec)
{
    if (likely(!exec->contended))
        return false;   /* 경합 없음 → 루프 종료 */

    /* 경합 발생: 모든 잠금 해제 */
    drm_exec_unlock_all(exec);

    /* 경합 객체에 slow path 잠금 */
    dma_resv_lock_slow(exec->contended->resv,
                        &exec->ticket);

    exec->prelocked++;
    exec->contended = NULL;
    return true;   /* 루프 재시도 */
}

실전 사용 예

/* GPU command submission에서의 drm_exec 사용 */

struct drm_exec exec;
int ret;

drm_exec_init(&exec, DRM_EXEC_INTERRUPTIBLE_WAIT
                      | DRM_EXEC_IGNORE_DUPLICATES, 0);

drm_exec_until_all_locked(&exec) {
    /* 소스 버퍼 잠금 */
    ret = drm_exec_prepare_obj(&exec, &src_bo->base, 1);
    drm_exec_retry_on_contention(&exec);
    if (ret)
        goto err;

    /* 대상 버퍼 잠금 */
    ret = drm_exec_prepare_obj(&exec, &dst_bo->base, 1);
    drm_exec_retry_on_contention(&exec);
    if (ret)
        goto err;

    /* 공유 커맨드 버퍼 잠금 */
    ret = drm_exec_prepare_obj(&exec, &cmd_bo->base, 0);
    drm_exec_retry_on_contention(&exec);
    if (ret)
        goto err;
}

/* 모든 BO 잠금 보유: GPU 작업 제출 */
dma_resv_add_fence(src_bo->base.resv, fence, DMA_RESV_USAGE_READ);
dma_resv_add_fence(dst_bo->base.resv, fence, DMA_RESV_USAGE_WRITE);
submit_to_gpu(ring, fence);

err:
drm_exec_fini(&exec);

커널 버전별 진화

ww_mutex는 2013년 Linux 3.11에서 처음 도입된 이후 지속적으로 발전해왔습니다. DRM 서브시스템의 요구에 맞춰 API가 확장되고, 성능 최적화와 디버깅 지원이 강화되었습니다.

주요 버전별 변경 이력

API 변경 가이드

/* v3.17 이전: reservation_object */
struct reservation_object *resv;
reservation_object_lock(resv, ctx);
reservation_object_unlock(resv);

/* v5.5+: dma_resv (이름 변경) */
struct dma_resv *resv;
dma_resv_lock(resv, ctx);
dma_resv_unlock(resv);

/* v6.0 이전: shared/exclusive fence 분리 */
dma_resv_add_shared_fence(resv, fence);
dma_resv_add_excl_fence(resv, fence);

/* v6.0+: usage 기반 통합 */
dma_resv_add_fence(resv, fence, DMA_RESV_USAGE_WRITE);
dma_resv_add_fence(resv, fence, DMA_RESV_USAGE_READ);

/* v6.4 이전: 수동 재시도 루프 */
ww_acquire_init(&ctx, &reservation_ww_class);
retry:
    ret = dma_resv_lock(resv, &ctx);
    if (ret == -EDEADLK) { ... goto retry; }

/* v6.4+: drm_exec 자동화 */
drm_exec_init(&exec, flags, 0);
drm_exec_until_all_locked(&exec) {
    drm_exec_prepare_obj(&exec, obj, num_fences);
    drm_exec_retry_on_contention(&exec);
}
drm_exec_fini(&exec);

참고 자료

커널 공식 문서

• Wound/Wait Deadlock-Proof Mutex Design — ww_mutex 공식 설계 문서
• Generic Mutex Subsystem — ww_mutex의 기반이 되는 mutex 설계
• Lock types and their rules — ww_mutex의 잠금 유형 분류
• DRM Memory Management — GEM/TTM 버퍼의 ww_mutex 사용 패턴

LWN.net 심층 기사

• Wait/wound mutexes (2013) — ww_mutex의 최초 도입과 wound-wait 알고리즘 설명
• The wait/wound mutex (2013) — wound-wait vs wait-die 알고리즘 비교
• The mutex API (2013) — 일반 mutex와 ww_mutex의 관계
• Lockdep: how to read its cryptic output (2013) — ww_mutex lockdep 경고 해석

학술 자료 및 외부 참고

• Rosenkrantz, Stearns & Lewis — "System Level Concurrency Control for Distributed Database Systems" (ACM TODS, 1978) — wound-wait/wait-die 알고리즘 원본 논문
• DRM Internals — DRM 서브시스템의 ww_mutex 활용 아키텍처
• 커널 소스: kernel/locking/ww_mutex.h, include/linux/ww_mutex.h
• DRM 사용 예시: drivers/gpu/drm/drm_gem.c, drivers/gpu/drm/ttm/
• drm_exec API: drivers/gpu/drm/drm_exec.c — ww_mutex 기반 최신 버퍼 잠금 API

관련 문서

ww_mutex와 관련된 다른 동기화 주제를 더 깊이 이해하고 싶다면 다음 문서를 참고하세요.

• 동기화 기법 — 전체 동기화 프리미티브 비교 및 선택 가이드
• Mutex — ww_mutex의 기반이 되는 일반 mutex 내부 구현
• 데드락 분석 — 데드락 4조건과 방지/회피/탐지 전략
• RT Mutex — Priority Inheritance 프로토콜, PREEMPT_RT에서의 mutex 변환
• Spinlock — 커널의 기본 busy-wait 동기화 프리미티브
• Semaphore — 카운팅 기반 동기화, mutex와의 비교
• 동시성 디버깅 — lockdep, KCSAN, perf lock 통합 가이드
• Lockdep — 잠금 의존성 그래프, 순환 탐지
• GPU 서브시스템 — DRM/KMS 아키텍처, GEM/TTM 버퍼 관리
• 메모리 배리어(Memory Barrier) — acquire/release 의미론, 아키텍처별 순서 보장