kref / refcount_t (참조 카운터)

커널 객체의 수명을 관리하는 참조 카운팅(Reference Counting) 메커니즘인 kref와 refcount_t를 심층 분석합니다. include/linux/kref.h에 정의된 kref API의 내부 구현, include/linux/refcount.h와 lib/refcount.c에 구현된 refcount_t의 saturation 보호 메커니즘, 기존 atomic_t에서 refcount_t로의 전환 이유와 역사, RCU와의 조합 패턴, kobject/device/sk_buff/file/dentry 등 실제 커널 서브시스템에서의 활용 사례, 그리고 흔한 실수와 디버깅(Debugging) 기법까지 커널 소스 기반으로 분석합니다.

개요: 참조 카운팅이 왜 필요한가

커널에서 동적으로 할당된 객체는 여러 서브시스템에서 동시에 참조될 수 있습니다. 예를 들어, 하나의 struct inode는 여러 프로세스의 struct file에서 참조되고, 동시에 페이지 캐시(Page Cache)와 디렉토리 엔트리(dentry)에서도 참조됩니다. 이때 "언제 이 객체를 안전하게 해제할 수 있는가?"라는 질문에 답하는 것이 참조 카운팅입니다.

Use-After-Free 문제

참조 카운팅 없이 객체를 관리하면 심각한 보안 취약점인 Use-After-Free(UAF)가 발생할 수 있습니다.

참조 카운팅은 이 문제를 근본적으로 해결합니다. Thread B가 객체를 사용하기 전에 참조 카운트를 증가시키면, Thread A가 kfree를 호출하더라도 카운트가 0이 아니므로 실제 해제가 일어나지 않습니다. Thread B가 사용을 마치고 참조를 해제하면 그때 비로소 카운트가 0이 되어 안전하게 해제됩니다.

참조 카운팅 vs 가비지 컬렉션

사용자 공간 언어(Java, Go, Python)는 가비지 컬렉터(GC)로 메모리를 자동 관리하지만, 커널에서는 결정적(Deterministic) 해제가 필요합니다.

커널에서 참조 카운팅을 사용하는 이유는 명확합니다. 인터럽트 핸들러(Interrupt Handler), softirq, 실시간 태스크(Task) 등에서 GC pause는 허용되지 않습니다. 참조 카운팅은 각 put 호출 시 상수 시간(O(1))으로 해제 여부를 결정하므로, 실시간 보장에 적합합니다.

참조 카운팅의 기본 원칙

kref 구조체

struct kref는 리눅스 커널에서 참조 카운팅을 위한 표준 래퍼입니다. include/linux/kref.h에 정의되어 있으며, 내부적으로 refcount_t를 감싸는 단순한 구조체입니다.

구조체 정의

/* include/linux/kref.h */
struct kref {
    refcount_t refcount;
};

kref는 단독으로 사용되지 않고, 반드시 관리 대상 객체의 구조체 안에 임베딩(Embedding)하여 사용합니다.

/* 사용 예: 커스텀 디바이스 구조체 */
struct my_device {
    struct kref     kref;
    char            name[64];
    struct list_head list;
    void            *private_data;
};

kref_init

/* include/linux/kref.h */
static inline void kref_init(struct kref *kref)
{
    refcount_set(&kref->refcount, 1);
}

kref_get

/* include/linux/kref.h */
static inline void kref_get(struct kref *kref)
{
    refcount_inc(&kref->refcount);
}

kref_put

/* include/linux/kref.h */
static inline int kref_put(struct kref *kref,
                           void (*release)(struct kref *kref))
{
    if (refcount_dec_and_test(&kref->refcount)) {
        release(kref);
        return 1;
    }
    return 0;
}

kref_put_mutex

/* include/linux/kref.h */
static inline int kref_put_mutex(struct kref *kref,
                                  void (*release)(struct kref *kref),
                                  struct mutex *lock)
{
    if (refcount_dec_and_mutex_lock(&kref->refcount, lock)) {
        release(kref);
        return 1;
    }
    return 0;
}

kref_get_unless_zero

/* include/linux/kref.h */
static inline int __must_check kref_get_unless_zero(struct kref *kref)
{
    return refcount_inc_not_zero(&kref->refcount);
}

refcount_t 구조체

refcount_t는 atomic_t를 대체하기 위해 도입된 참조 카운터 전용 타입입니다. 단순 정수 래퍼처럼 보이지만, 컴파일 타임(Compile Time)과 런타임(Runtime) 모두에서 보호 메커니즘을 제공합니다.

구조체 정의

/* include/linux/refcount.h */
typedef struct refcount_struct {
    atomic_t refs;
} refcount_t;

atomic_t에서 refcount_t로의 전환 이유

커널 v4.11(2017년)에서 refcount_t가 도입된 배경에는 심각한 보안 문제가 있었습니다.

Saturation 보호 메커니즘

refcount_t의 핵심 보호 메커니즘은 saturation(포화)입니다. 카운트가 비정상적인 값에 도달하면 더 이상 변경을 허용하지 않고 경고를 발생시킵니다.

/* include/linux/refcount.h */
#define REFCOUNT_INIT(n)    { .refs = ATOMIC_INIT(n), }
#define REFCOUNT_MAX        INT_MAX
#define REFCOUNT_SATURATED  (INT_MIN / 2)

refcount_t API

refcount_t는 include/linux/refcount.h에 다양한 API를 제공합니다. 각 함수는 saturation 보호 로직이 내장되어 있습니다.

기본 API

/* 초기화 */
#define REFCOUNT_INIT(n)  { .refs = ATOMIC_INIT(n) }

static inline void refcount_set(refcount_t *r, int n)
{
    atomic_set(&r->refs, n);
}

/* 읽기 */
static inline unsigned int refcount_read(const refcount_t *r)
{
    return atomic_read(&r->refs);
}

refcount_inc / refcount_inc_not_zero

/* lib/refcount.c — 간소화된 핵심 로직 */
void refcount_inc(refcount_t *r)
{
    int old = atomic_fetch_add_relaxed(1, &r->refs);

    /* old가 0이면 이미 해제된 객체에 대한 inc — 버그 */
    if (unlikely(!old))
        refcount_warn_saturate(r, REFCOUNT_ADD_UAF);
    /* old가 음수면 이미 saturated — 변경 없이 유지 */
    else if (unlikely(old < 0 || old + 1 < 0))
        refcount_warn_saturate(r, REFCOUNT_ADD_OVF);
}

bool refcount_inc_not_zero(refcount_t *r)
{
    int old = atomic_read(&r->refs);

    do {
        if (!old)
            return false;
    } while (!atomic_try_cmpxchg_relaxed(&r->refs, &old, old + 1));

    if (unlikely(old < 0 || old + 1 < 0))
        refcount_warn_saturate(r, REFCOUNT_ADD_OVF);

    return true;
}

refcount_dec_and_test / refcount_dec_and_lock

/* lib/refcount.c — 간소화된 핵심 로직 */
bool refcount_dec_and_test(refcount_t *r)
{
    int old = atomic_fetch_sub_release(1, &r->refs);

    if (old == 1) {
        smp_acquire__after_ctrl_dep();
        return true;
    }

    if (unlikely(old <= 0)) {
        /* old == 0이면 이미 해제된 객체, old < 0이면 saturated */
        refcount_warn_saturate(r, REFCOUNT_SUB_UAF);
        return false;
    }

    return false;
}

/* release와 동시에 spinlock 획득 */
bool refcount_dec_and_lock(refcount_t *r, spinlock_t *lock)
{
    if (refcount_dec_not_one(r))
        return false;

    spin_lock(lock);
    if (!refcount_dec_and_test(r)) {
        spin_unlock(lock);
        return false;
    }

    return true;
}

API 전체 요약

kref vs atomic_t vs refcount_t 비교

세 가지 참조 카운팅 방법의 차이를 명확히 비교합니다.

생명주기 패턴

참조 카운팅 기반의 객체 생명주기는 "생성 → 참조 획득 → 사용 → 참조 해제 → 소멸"의 5단계를 따릅니다.

release 콜백 패턴

struct my_device {
    struct kref       kref;
    char              *name;
    struct list_head  list;
};

/* release 콜백 — kref_put에서 refcount가 0이 될 때 호출됩니다 */
static void my_device_release(struct kref *kref)
{
    struct my_device *dev = container_of(kref, struct my_device, kref);

    pr_info("releasing device %s\n", dev->name);
    kfree(dev->name);
    kfree(dev);
}

/* 생성 */
struct my_device *my_device_create(const char *name)
{
    struct my_device *dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    if (!dev)
        return NULL;

    dev->name = kstrdup(name, GFP_KERNEL);
    if (!dev->name) {
        kfree(dev);
        return NULL;
    }

    kref_init(&dev->kref);  /* refcount = 1 */
    return dev;
}

/* 참조 획득 */
struct my_device *my_device_get(struct my_device *dev)
{
    if (dev)
        kref_get(&dev->kref);
    return dev;
}

/* 참조 해제 */
void my_device_put(struct my_device *dev)
{
    if (dev)
        kref_put(&dev->kref, my_device_release);
}

RCU와 참조 카운터

RCU(Read-Copy-Update)와 참조 카운터의 조합은 커널에서 가장 중요한 동시성 패턴 중 하나입니다. 이 패턴은 "잠금(Lock) 없는 읽기 경로에서 안전하게 객체 참조를 획득"하는 문제를 해결합니다.

문제: RCU 읽기 구간 밖에서의 객체 접근

RCU는 읽기 측(Read-side)이 잠금 없이 데이터를 읽을 수 있게 하지만, rcu_read_lock()/rcu_read_unlock() 구간 밖에서는 객체가 이미 해제되었을 수 있습니다. 따라서 RCU 읽기 구간 안에서 객체를 찾아 참조 카운트를 증가시킨 후, RCU 구간 밖에서 안전하게 사용해야 합니다.

RCU + kref 코드 패턴

/* 안전한 RCU lookup + 참조 획득 패턴 */
struct my_device *find_device_by_id(int id)
{
    struct my_device *dev;

    rcu_read_lock();
    list_for_each_entry_rcu(dev, &device_list, list) {
        if (dev->id == id) {
            /* 핵심: 0이 아닌 경우에만 참조 획득 */
            if (!kref_get_unless_zero(&dev->kref)) {
                dev = NULL;  /* 이미 해제 중 */
            }
            rcu_read_unlock();
            return dev;
        }
    }
    rcu_read_unlock();
    return NULL;
}

/* 객체 제거 (writer 측) */
void remove_device(struct my_device *dev)
{
    spin_lock(&device_lock);
    list_del_rcu(&dev->list);
    spin_unlock(&device_lock);

    /* writer의 참조 해제 — 다른 reader가 get에 성공했으면 아직 해제되지 않습니다 */
    kref_put(&dev->kref, my_device_release);
}

커널 활용 사례

리눅스 커널의 주요 서브시스템은 참조 카운팅을 광범위하게 사용합니다. 대표적인 사례를 살펴봅니다.

kobject (sysfs)

/* include/linux/kobject.h */
struct kobject {
    const char          *name;
    struct list_head    entry;
    struct kobject      *parent;
    struct kset         *kset;
    const struct kobj_type *ktype;
    struct kernfs_node *sd;
    struct kref         kref;           /* ← kref 임베딩 */
    unsigned int        state_initialized:1;
    unsigned int        state_in_sysfs:1;
    unsigned int        state_add_uevent_sent:1;
    unsigned int        state_remove_uevent_sent:1;
    unsigned int        uevent_suppress:1;
};

/* lib/kobject.c */
struct kobject *kobject_get(struct kobject *kobj)
{
    if (kobj) {
        if (!kobj->state_initialized)
            WARN(1, "kobject: '%s' is not initialized, yet kobject_get() is called\n",
                 kobject_name(kobj));
        kref_get(&kobj->kref);
    }
    return kobj;
}
EXPORT_SYMBOL(kobject_get);

void kobject_put(struct kobject *kobj)
{
    if (kobj) {
        if (!kobj->state_initialized)
            WARN(1, "kobject: '%s' is not initialized, yet kobject_put() is called\n",
                 kobject_name(kobj));
        kref_put(&kobj->kref, kobject_release);
    }
}
EXPORT_SYMBOL(kobject_put);

struct device

/* drivers/base/core.c */
struct device *get_device(struct device *dev)
{
    return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;
}
EXPORT_SYMBOL_GPL(get_device);

void put_device(struct device *dev)
{
    if (dev)
        kobject_put(&dev->kobj);
}
EXPORT_SYMBOL_GPL(put_device);

struct sk_buff

/* include/linux/skbuff.h */
struct sk_buff {
    /* ... */
    refcount_t  users;   /* sk_buff 자체의 참조 카운트 */
};

/* net/core/skbuff.c */
static inline struct sk_buff *skb_get(struct sk_buff *skb)
{
    refcount_inc(&skb->users);
    return skb;
}

void kfree_skb(struct sk_buff *skb)
{
    if (!skb)
        return;
    if (likely(refcount_read(&skb->users) == 1))
        slab_free_after_rcu_gp(skb_free_head, skb);
    else if (likely(!refcount_dec_and_test(&skb->users)))
        return;
    else
        __kfree_skb(skb);
}

struct file

/* include/linux/fs.h */
struct file {
    /* ... */
    atomic_long_t       f_count;   /* 참조 카운트 */
    /* ... */
};

/* fs/file_table.c */
struct file *get_file(struct file *f)
{
    atomic_long_inc(&f->f_count);
    return f;
}

/* fget — fd 테이블에서 file 획득 (RCU 기반) */
struct file *fget(unsigned int fd)
{
    struct file *file;

    rcu_read_lock();
    file = fcheck_files(current->files, fd);
    if (file && !atomic_long_inc_not_zero(&file->f_count))
        file = NULL;
    rcu_read_unlock();

    return file;
}

struct dentry

/* include/linux/dcache.h */
struct dentry {
    unsigned int      d_flags;
    seqcount_spinlock_t d_seq;
    struct hlist_bl_node d_hash;
    struct dentry    *d_parent;
    struct qstr       d_name;
    struct inode     *d_inode;
    unsigned char    d_iname[DNAME_INLINE_LEN];
    lockref_t         d_lockref;    /* 참조 카운트 + spinlock 통합 */
    /* ... */
};

struct dentry는 lockref_t를 사용합니다. lockref_t는 참조 카운트와 spinlock을 단일 64비트(Bit) 워드에 통합하여, dget/dput 시 cmpxchg 한 번으로 카운트 증감과 동기화를 동시에 수행하는 최적화입니다.

kobject와 kref

kobject는 kref의 가장 대표적이고 중요한 사용자입니다. 커널의 전체 디바이스 모델(Device Model)은 kobject 트리 위에 구축되며, 이 트리의 각 노드는 kref로 수명이 관리됩니다.

kobject 생명주기와 kref

/* lib/kobject.c — kobject_release (간소화) */
static void kobject_release(struct kref *kref)
{
    struct kobject *kobj = container_of(kref, struct kobject, kref);

    /* 지연 해제가 필요하면 workqueue에 위임합니다 */
    if (kobj->state_in_sysfs) {
        kobject_uevent(kobj, KOBJ_REMOVE);
        sysfs_remove_groups(kobj, kobj->ktype->default_groups);
        sysfs_remove_dir(kobj);
    }

    /* ktype의 release 콜백 호출 — 실제 메모리 해제 */
    if (kobj->ktype && kobj->ktype->release)
        kobj->ktype->release(kobj);

    /* 부모 kobject 참조 해제 — 재귀적 해제 가능 */
    if (kobj->parent)
        kobject_put(kobj->parent);
}

디버깅

참조 카운터 관련 버그는 재현이 어렵고 디버깅이 까다로운 것으로 유명합니다. 커널은 여러 도구를 제공하여 이러한 버그를 탐지합니다.

refcount_t saturation WARN

refcount_t가 비정상적인 상태를 탐지하면 다음과 같은 WARN 메시지를 출력합니다.

refcount_t: addition on 0; use-after-free.
WARNING: CPU: 2 PID: 1234 at lib/refcount.c:25 refcount_warn_saturate+0x65/0x80
Call Trace:
 refcount_inc+0x3a/0x40
 my_device_get+0x15/0x20 [my_module]
 my_work_handler+0x42/0x80 [my_module]

refcount_t: underflow; use-after-free.
WARNING: CPU: 0 PID: 5678 at lib/refcount.c:28 refcount_warn_saturate+0x80/0x80
Call Trace:
 refcount_dec_and_test+0x35/0x50
 my_device_put+0x18/0x30 [my_module]
 my_cleanup+0x25/0x40 [my_module]

KASAN (Kernel Address Sanitizer)

KASAN은 Use-After-Free를 메모리 접근 시점에서 탐지합니다. refcount_t saturation이 "카운터 오류"를 탐지한다면, KASAN은 "실제로 해제된 메모리에 접근했는가"를 탐지합니다.

# 참조 카운터 디버깅 관련 커널 설정
CONFIG_KASAN=y              # 메모리 접근 오류 탐지
CONFIG_KASAN_GENERIC=y      # 소프트웨어 기반 (더 느리지만 정확)
CONFIG_DEBUG_OBJECTS=y       # 객체 상태 추적
CONFIG_DEBUG_OBJECTS_FREE=y  # 해제된 객체 접근 탐지
CONFIG_PROVE_LOCKING=y      # lockdep — 잠금 순서 검증

CONFIG_REFCOUNT_FULL (역사적 맥락)

커널 v4.12~v5.4에서는 CONFIG_REFCOUNT_FULL 옵션이 있었습니다. 이 옵션이 꺼져 있으면 refcount_t가 atomic_t와 동일하게 동작했고(보호 없음), 켜져 있을 때만 saturation 보호가 활성화되었습니다.

커널 v5.5(2020년 1월)부터 Peter Zijlstra의 패치로 saturation 보호가 항상 활성화되었고, 성능 오버헤드가 x86에서 0%로 최적화되었습니다. 이후 CONFIG_REFCOUNT_FULL 옵션은 제거되었습니다.

/* 디버깅 유틸리티: 현재 참조 카운트 출력 */
static void debug_print_refcount(struct my_device *dev, const char *ctx)
{
    pr_debug("%s: device '%s' refcount=%u\n",
             ctx, dev->name,
             refcount_read(&dev->kref.refcount));
}

/* WARN_ON을 활용한 참조 카운트 검증 */
void my_device_validate(struct my_device *dev)
{
    unsigned int count = refcount_read(&dev->kref.refcount);

    /* 카운트가 비정상적으로 높으면 leak 가능성 */
    WARN_ON(count > 1000);
    /* 카운트가 0이면 이미 해제 중 — 접근하면 안 됩니다 */
    WARN_ON(!count);
}

ftrace로 참조 카운트 추적

# kobject_get/kobject_put 호출 추적
echo 1 > /sys/kernel/debug/tracing/events/kobject/kobject_get/enable
echo 1 > /sys/kernel/debug/tracing/events/kobject/kobject_put/enable
cat /sys/kernel/debug/tracing/trace_pipe

# 특정 함수의 호출 스택 추적
echo 'refcount_warn_saturate' > /sys/kernel/debug/tracing/set_ftrace_filter
echo function > /sys/kernel/debug/tracing/current_tracer
echo 1 > /sys/kernel/debug/tracing/options/func_stack_trace

atomic_t → refcount_t 마이그레이션

커널에서 atomic_t를 참조 카운터로 사용하는 코드를 refcount_t로 전환하는 작업은 2017년부터 시작되어 수년에 걸쳐 진행되었습니다.

전환 타임라인

Coccinelle 변환 스크립트

커널 트리에는 atomic_t를 refcount_t로 자동 변환하는 Coccinelle(시맨틱 패치) 스크립트가 포함되어 있습니다.

// scripts/coccinelle/api/atomic_as_refcounter.cocci (간소화)
// atomic_t를 refcount 용도로 사용하는 패턴 탐지

@@
identifier a, x;
identifier fname =~ ".*_get";
@@

fname(...) {
  ...
- atomic_inc(&x->a);
+ refcount_inc(&x->a);
  ...
}

@@
identifier a, x;
identifier fname =~ ".*_put";
@@

fname(...) {
  ...
- if (atomic_dec_and_test(&x->a))
+ if (refcount_dec_and_test(&x->a))
  ...
}

# Coccinelle 스크립트 실행 (탐지만)
spatch --sp-file scripts/coccinelle/api/atomic_as_refcounter.cocci \
       --dir drivers/usb/ --mode=report

# 자동 변환 적용
spatch --sp-file scripts/coccinelle/api/atomic_as_refcounter.cocci \
       --dir drivers/usb/ --mode=patch --in-place

수동 마이그레이션 가이드

/* 변환 전 (atomic_t 기반) */
struct my_obj {
    atomic_t refcnt;
};

static void obj_get(struct my_obj *obj)
{
    atomic_inc(&obj->refcnt);
}

static void obj_put(struct my_obj *obj)
{
    if (atomic_dec_and_test(&obj->refcnt))
        kfree(obj);
}

/* ──────────────────────────────────── */

/* 변환 후 (refcount_t 기반) */
struct my_obj {
    refcount_t refcnt;
};

static void obj_get(struct my_obj *obj)
{
    refcount_inc(&obj->refcnt);
}

static void obj_put(struct my_obj *obj)
{
    if (refcount_dec_and_test(&obj->refcnt))
        kfree(obj);
}

흔한 실수와 방지

참조 카운팅 코드에서 자주 발생하는 실수와 그 방지 방법을 정리합니다.

실수 1: Double-Free (이중 해제)

/* ❌ 잘못된 코드: kref_put을 두 번 호출 */
void bad_cleanup(struct my_device *dev)
{
    kref_put(&dev->kref, my_device_release);
    /* ... 다른 정리 작업 ... */
    kref_put(&dev->kref, my_device_release);  /* 💥 두 번째 put — 이미 해제됨! */
}

/* ✅ 올바른 코드: get/put 쌍을 정확히 맞춤 */
void good_cleanup(struct my_device *dev)
{
    /* 이 함수가 보유한 참조 1개만 해제 */
    kref_put(&dev->kref, my_device_release);
    /* 이후 dev 포인터를 사용하지 않음 */
}

실수 2: 조건부 Get 누락

/* ❌ 잘못된 코드: RCU 구간에서 kref_get 사용 */
struct my_device *bad_lookup(int id)
{
    struct my_device *dev;
    rcu_read_lock();
    list_for_each_entry_rcu(dev, &list, node) {
        if (dev->id == id) {
            kref_get(&dev->kref);  /* 💥 refcount가 0일 수 있음! */
            rcu_read_unlock();
            return dev;
        }
    }
    rcu_read_unlock();
    return NULL;
}

/* ✅ 올바른 코드: kref_get_unless_zero 사용 */
struct my_device *good_lookup(int id)
{
    struct my_device *dev;
    rcu_read_lock();
    list_for_each_entry_rcu(dev, &list, node) {
        if (dev->id == id) {
            if (!kref_get_unless_zero(&dev->kref))
                dev = NULL;
            rcu_read_unlock();
            return dev;
        }
    }
    rcu_read_unlock();
    return NULL;
}

실수 3: Release 콜백 내 잘못된 접근

/* ❌ 잘못된 코드: release 후 멤버 접근 */
static void bad_release(struct kref *kref)
{
    struct my_device *dev = container_of(kref, struct my_device, kref);

    kfree(dev);
    pr_info("freed %s\n", dev->name);  /* 💥 이미 해제된 메모리 접근! */
}

/* ✅ 올바른 코드: kfree 전에 필요한 작업 완료 */
static void good_release(struct kref *kref)
{
    struct my_device *dev = container_of(kref, struct my_device, kref);

    pr_info("freeing %s\n", dev->name);  /* kfree 전에 접근 */
    kfree(dev->name);
    kfree(dev);
}

실수 4: 에러 경로에서 put 누락 (참조 누수)

/* ❌ 잘못된 코드: 에러 경로에서 kref_put 빠짐 */
int bad_use_device(struct my_device *dev)
{
    kref_get(&dev->kref);

    if (do_something(dev) < 0)
        return -EIO;  /* 💥 kref_put 없이 반환 — 영원히 해제되지 않음! */

    kref_put(&dev->kref, my_device_release);
    return 0;
}

/* ✅ 올바른 코드: 모든 경로에서 put 보장 */
int good_use_device(struct my_device *dev)
{
    int ret;

    kref_get(&dev->kref);

    ret = do_something(dev);

    kref_put(&dev->kref, my_device_release);
    return ret;
}

실수 요약 표

소스 코드 워크스루

refcount_dec_and_test의 내부 구현을 커널 소스 기반으로 단계별 추적합니다.

refcount_dec_and_test 내부 구현 추적

/* include/linux/refcount.h */
static inline bool __refcount_dec_and_test(
    refcount_t *r, int *oldp)
{
    int old = atomic_fetch_sub_release(1, &r->refs);

    if (oldp)
        *oldp = old;

    if (old == 1) {
        smp_acquire__after_ctrl_dep();
        return true;
    }

    if (unlikely(old <= 0))
        refcount_warn_saturate(r, REFCOUNT_SUB_UAF);

    return false;
}

static inline bool refcount_dec_and_test(refcount_t *r)
{
    return __refcount_dec_and_test(r, NULL);
}

메모리 순서 보장의 중요성

왜 refcount_dec_and_test에서 release와 acquire 배리어가 모두 필요한지 구체적인 시나리오로 설명합니다.

/* CPU A: 객체 수정 후 참조 해제 */
dev->data = 42;                          /* (1) store: 데이터 수정 */
kref_put(&dev->kref, release);          /* (2) release barrier + dec */

/* CPU B: 마지막 참조 해제 → release 콜백 */
kref_put(&dev->kref, release);          /* (3) release + dec → 0! */
/* (3)에서 acquire barrier 추가 */

static void release(struct kref *kref) {
    struct my_device *dev = container_of(...);
    pr_info("data = %d\n", dev->data);   /* (4) load: CPU A의 42가 보여야 함 */
    kfree(dev);
}

/*
 * release barrier (2): (1)의 store가 (2)의 dec 전에 완료됨을 보장
 * acquire barrier (3): (3)의 dec 이후의 (4) load가 (1)의 store를 볼 수 있음을 보장
 * 이 두 배리어가 합쳐져, CPU B의 release 콜백에서 CPU A의 수정 사항이 보입니다.
 */

고급 패턴

percpu_ref: 고성능 참조 카운터

일반적인 refcount_t는 모든 CPU가 동일한 캐시라인(Cache Line)을 경합합니다. 매우 빈번한 참조 획득/해제가 있는 경우(예: I/O 경로), percpu_ref가 더 효율적입니다.

/* include/linux/percpu-refcount.h */
struct percpu_ref {
    atomic_long_t           count;
    unsigned long __percpu  *percpu_count_ptr;
    percpu_ref_func_t       *release;
    percpu_ref_func_t       *confirm_switch;
    bool                    force_atomic:1;
    struct rcu_head          rcu;
};

/* 사용 예: block I/O */
percpu_ref_init(&q->q_usage_counter, blk_queue_usage_counter_release,
                PERCPU_REF_INIT_ATOMIC, GFP_KERNEL);

/* fast path: per-CPU 카운터 증가 (캐시라인 경합 없음) */
percpu_ref_get(&q->q_usage_counter);

/* slow path: kill 시 global atomic으로 전환 */
percpu_ref_kill(&q->q_usage_counter);

devm 리소스와 참조 카운팅

디바이스 드라이버(Device Driver)에서는 devm_* API를 사용하여 디바이스 수명에 자원을 묶을 수 있습니다. 이는 참조 카운팅과 상호보완적입니다.

/* 디바이스 수명에 묶인 자원 할당 */
int my_probe(struct platform_device *pdev)
{
    struct my_device *dev;

    /* devm_kzalloc: pdev 해제 시 자동으로 kfree됩니다 */
    dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
    if (!dev)
        return -ENOMEM;

    /* 주의: devm으로 할당한 객체에 kref를 사용하면
     * release 콜백에서 kfree를 호출하면 안 됩니다.
     * devm이 이미 해제를 관리하기 때문입니다. */

    platform_set_drvdata(pdev, dev);
    return 0;
}

아키텍처별 구현 차이

refcount_t의 원자적 연산은 아키텍처마다 다른 명령어로 구현됩니다. 성능 특성과 메모리 순서 보장 방식이 다르므로 이해가 필요합니다.

x86: LOCK 접두사

; refcount_dec_and_test → atomic_fetch_sub_release(1, &r->refs)
; x86에서 LOCK XADD는 이미 full barrier이므로
; release 의미론이 추가 비용 없이 보장됩니다.

lock xadd   DWORD PTR [rdi], eax    ; 원자적 교환+덧셈
cmp        eax, 1                   ; 이전 값이 1이었으면
je         .Lrelease                ; → release 호출
test       eax, eax                 ; 이전 값이 0 이하이면
jle        .Lwarn_saturate          ; → WARN
ret                                  ; 정상: false 반환

; refcount_inc → atomic_fetch_add_relaxed(1, &r->refs)
lock xadd   DWORD PTR [rdi], eax    ; 원자적 교환+덧셈
test       eax, eax                 ; 이전 값이 0이면 UAF
je         .Lwarn_uaf

ARM64: LSE / LL/SC

// ARM64 LSE (Large System Extensions) 사용 시
// refcount_dec_and_test → atomic_fetch_sub_release

ldaddal    w2, w0, [x0]        // atomic fetch-add with acquire+release
cmp        w0, #1              // 이전 값 == 1?
b.eq       release_path        // → release 호출
cmp        w0, #0              // 이전 값 <= 0?
b.le       warn_path           // → WARN saturate

// ARM64 LL/SC (LSE 미지원 시)
// refcount_inc_not_zero → CAS 루프

1:
ldxr       w1, [x0]            // Load-Exclusive: 현재 값 읽기
cbz        w1, fail            // 0이면 실패
add        w2, w1, #1          // +1
stxr       w3, w2, [x0]        // Store-Exclusive: 조건부 저장
cbnz       w3, 1b              // 실패 시 재시도

RISC-V: AMO / LR/SC

# RISC-V: refcount_dec_and_test → atomic_fetch_sub_release
# AMO (Atomic Memory Operation) 사용

amoadd.w.rl  a0, a1, (a2)    # release 순서 atomic add
li           t0, 1
beq          a0, t0, release  # 이전 값 == 1 → release
blez         a0, warn         # 이전 값 <= 0 → WARN

# RISC-V: refcount_inc_not_zero → LR/SC 루프

1:
lr.w         a1, (a0)         # Load-Reserved
beqz         a1, fail         # 0이면 실패
addi         a2, a1, 1        # +1
sc.w         a3, a2, (a0)     # Store-Conditional
bnez         a3, 1b           # 실패 시 재시도

아키텍처별 비교 요약

성능 분석

참조 카운팅의 성능 특성을 이해하는 것은 올바른 메커니즘 선택에 중요합니다.

캐시라인 경합 분석

벤치마크 데이터

핵심 결론: refcount_t의 saturation 보호는 실질적으로 측정 불가능한 수준의 오버헤드만 추가합니다. x86에서는 기존 LOCK XADD 이후 조건 분기 하나가 추가되는 것뿐이며, 분기 예측기(Branch Predictor)가 정상 경로를 정확히 예측하므로 파이프라인(Pipeline) 지연이 발생하지 않습니다.

# cache miss 기반 경합 측정
perf stat -e cache-misses,cache-references,instructions \
    -a -- sleep 10

# lock contention 분석 (refcount 관련 함수)
perf lock record -a -- sleep 5
perf lock report

# 특정 함수 호출 빈도 측정
perf probe --add 'refcount_inc'
perf stat -e 'probe:refcount_inc' -a -- sleep 5

# c2c (cache-to-cache) 분석 — 캐시라인 바운싱 탐지
perf c2c record -a -- sleep 10
perf c2c report --stdio

참조 카운터 선택 가이드

실전 패턴 모음

커널에서 흔히 사용되는 참조 카운팅 패턴을 모아 정리합니다.

패턴 1: Workqueue와 참조 카운팅

/*
 * 워크큐에 작업을 제출할 때, 작업이 완료될 때까지
 * 객체가 유효해야 합니다.
 */
void schedule_device_work(struct my_device *dev)
{
    /* 작업 제출 전 참조 획득 */
    kref_get(&dev->kref);

    if (!queue_work(system_wq, &dev->work)) {
        /* 이미 큐에 있으면 참조 되돌림 */
        kref_put(&dev->kref, my_device_release);
    }
}

static void device_work_handler(struct work_struct *work)
{
    struct my_device *dev = container_of(work, struct my_device, work);

    /* 작업 수행 */
    do_device_processing(dev);

    /* 작업 완료 후 참조 해제 */
    kref_put(&dev->kref, my_device_release);
}

패턴 2: 타이머와 참조 카운팅

/*
 * 타이머 콜백에서 객체에 접근하려면
 * 타이머 활성화 기간 동안 참조를 유지해야 합니다.
 */
void start_device_timer(struct my_device *dev)
{
    kref_get(&dev->kref);  /* 타이머용 참조 */
    mod_timer(&dev->timer, jiffies + HZ);
}

static void device_timer_callback(struct timer_list *t)
{
    struct my_device *dev = from_timer(dev, t, timer);

    /* 타이머 작업 수행 */
    check_device_status(dev);

    /* 타이머 재스케줄 또는 참조 해제 */
    if (dev->needs_monitoring) {
        mod_timer(&dev->timer, jiffies + HZ);
        /* 참조 유지 — 다음 콜백에서 해제 */
    } else {
        kref_put(&dev->kref, my_device_release);
    }
}

void stop_device_timer(struct my_device *dev)
{
    /* 타이머가 실행 중이면 완료까지 대기 후 삭제 */
    if (del_timer_sync(&dev->timer)) {
        /* 타이머가 아직 실행 안 됨 → 콜백이 put하지 못하므로 여기서 해제 */
        kref_put(&dev->kref, my_device_release);
    }
}

패턴 3: 분리된 참조 카운트 (수명 vs 활성)

/*
 * 일부 커널 객체는 두 개의 참조 카운트를 사용합니다:
 * - refcount: 객체 수명 (0이면 메모리 해제)
 * - active: 활성 사용 (0이면 비활성화, 메모리는 유지)
 *
 * 예: struct super_block의 s_count(수명) + s_active(마운트)
 * 예: struct module의 refcnt(수명) + mkobj.kobj.kref(sysfs)
 */
struct my_subsystem {
    refcount_t    refcount;   /* 메모리 수명 관리 */
    atomic_t      active;     /* 활성 사용자 수 */
    struct rcu_head rcu;
    bool          dead;       /* 비활성화 플래그 */
};

/* 활성 사용 시작 */
bool subsystem_activate(struct my_subsystem *s)
{
    if (READ_ONCE(s->dead))
        return false;  /* 이미 비활성화됨 */
    atomic_inc(&s->active);
    if (READ_ONCE(s->dead)) {
        atomic_dec(&s->active);
        return false;
    }
    return true;
}

/* 비활성화 (새 사용자 차단, 기존 사용자 완료 대기) */
void subsystem_deactivate(struct my_subsystem *s)
{
    WRITE_ONCE(s->dead, true);
    synchronize_rcu();
    /* 모든 active 사용자가 종료될 때까지 대기 */
    wait_event(s->waitq, atomic_read(&s->active) == 0);
    /* 수명 참조 해제 */
    subsystem_put(s);
}

패턴 4: 콜백 데이터 참조 관리

/*
 * 비동기 콜백에 데이터를 전달할 때,
 * 콜백이 실행될 시점에 데이터가 유효해야 합니다.
 */
struct async_request {
    struct kref       kref;
    struct my_device  *dev;      /* 디바이스 참조 */
    void              *buffer;
    size_t            size;
    completion_t      done;
};

static void async_request_release(struct kref *kref)
{
    struct async_request *req = container_of(kref, struct async_request, kref);

    /* 디바이스 참조도 해제 */
    kref_put(&req->dev->kref, my_device_release);
    kfree(req->buffer);
    kfree(req);
}

int submit_async_request(struct my_device *dev, void *data, size_t len)
{
    struct async_request *req;

    req = kzalloc(sizeof(*req), GFP_KERNEL);
    if (!req)
        return -ENOMEM;

    kref_init(&req->kref);     /* req refcount = 1 */
    kref_get(&dev->kref);      /* 디바이스 참조 획득 */
    req->dev = dev;
    req->buffer = kmemdup(data, len, GFP_KERNEL);
    req->size = len;

    /* 하드웨어에 제출 — 완료 시 콜백 호출 */
    kref_get(&req->kref);  /* 콜백용 참조 */
    hw_submit(dev->hw, req->buffer, req->size, async_callback, req);

    /* 제출자의 참조 해제 */
    kref_put(&req->kref, async_request_release);
    return 0;
}

static void async_callback(void *context, int status)
{
    struct async_request *req = context;

    pr_info("async request completed: status=%d\n", status);
    /* 콜백의 참조 해제 — 마지막이면 release 호출 */
    kref_put(&req->kref, async_request_release);
}

패턴 5: sysfs 속성과 참조 카운팅

/*
 * sysfs 속성 핸들러에서는 kobject_get/put이
 * 프레임워크에 의해 자동으로 관리됩니다.
 * 하지만 속성 핸들러 안에서 다른 객체를 참조할 때는
 * 직접 관리해야 합니다.
 */
static ssize_t peer_show(struct device *dev,
                         struct device_attribute *attr,
                         char *buf)
{
    struct my_device *mydev = dev_get_drvdata(dev);
    struct my_device *peer;
    ssize_t ret;

    rcu_read_lock();
    peer = rcu_dereference(mydev->peer);
    if (peer && kref_get_unless_zero(&peer->kref)) {
        rcu_read_unlock();
        ret = sysfs_emit(buf, "%s\n", peer->name);
        kref_put(&peer->kref, my_device_release);
    } else {
        rcu_read_unlock();
        ret = sysfs_emit(buf, "(none)\n");
    }

    return ret;
}

lockref: 참조 카운트와 Lock의 통합

lockref_t는 참조 카운트와 spinlock을 단일 64비트 워드에 통합한 최적화된 자료구조입니다. 주로 struct dentry에서 사용됩니다.

lockref 구조체

/* include/linux/lockref.h */
struct lockref {
    union {
#if CONFIG_ARCH_USE_CMPXCHG_LOCKREF
        aligned_u64 lock_count;  /* lock + count 통합 */
#endif
        struct {
            spinlock_t    lock;
            int           count;
        };
    };
};

/* lib/lockref.c — lockref_get (간소화) */
void lockref_get(struct lockref *lockref)
{
    CMPXCHG_LOOP(
        new.count++;
    ,
        return;
    );

    /* cmpxchg 실패 시 fallback: lock 획득 후 count++ */
    spin_lock(&lockref->lock);
    lockref->count++;
    spin_unlock(&lockref->lock);
}

/* lockref_put_return — dput의 fast path */
int lockref_put_return(struct lockref *lockref)
{
    CMPXCHG_LOOP(
        new.count--;
        if (old.count <= 0)
            return -1;
    ,
        return new.count;
    );
    return -1;
}

refcount_warn_saturate 구현 상세

saturation 보호의 핵심인 refcount_warn_saturate 함수의 구현을 상세히 분석합니다.

/* lib/refcount.c */
void refcount_warn_saturate(refcount_t *r, enum refcount_saturation_type t)
{
    /* 카운트를 REFCOUNT_SATURATED로 고정 */
    atomic_set(&r->refs, REFCOUNT_SATURATED);

    switch (t) {
    case REFCOUNT_ADD_NOT_ZERO:
        WARN_ONCE(true, "refcount_t: saturated; leaking memory.\n");
        break;

    case REFCOUNT_ADD_OVF:
        WARN_ONCE(true, "refcount_t: overflow; use-after-free.\n");
        break;

    case REFCOUNT_ADD_UAF:
        WARN_ONCE(true, "refcount_t: addition on 0; use-after-free.\n");
        break;

    case REFCOUNT_SUB_UAF:
        WARN_ONCE(true, "refcount_t: underflow; use-after-free.\n");
        break;

    default:
        WARN_ONCE(true, "refcount_t: unknown saturation event!?\n");
    }
}

Saturation 이벤트 유형

참조 카운터 테스트 전략

참조 카운팅 코드를 테스트하는 것은 까다롭지만 필수적입니다. 커널은 여러 테스트 프레임워크를 제공합니다.

KUnit 기반 단위 테스트

/*
 * 참조 카운터 KUnit 테스트 예제
 * lib/refcount_test.c (커널 트리 내)
 */
#include <kunit/test.h>
#include <linux/refcount.h>

static void test_refcount_init(struct kunit *test)
{
    refcount_t r = REFCOUNT_INIT(1);
    KUNIT_EXPECT_EQ(test, refcount_read(&r), 1);
}

static void test_refcount_inc_dec(struct kunit *test)
{
    refcount_t r = REFCOUNT_INIT(1);

    refcount_inc(&r);
    KUNIT_EXPECT_EQ(test, refcount_read(&r), 2);

    refcount_inc(&r);
    KUNIT_EXPECT_EQ(test, refcount_read(&r), 3);

    KUNIT_EXPECT_FALSE(test, refcount_dec_and_test(&r));
    KUNIT_EXPECT_EQ(test, refcount_read(&r), 2);

    KUNIT_EXPECT_FALSE(test, refcount_dec_and_test(&r));
    KUNIT_EXPECT_EQ(test, refcount_read(&r), 1);

    KUNIT_EXPECT_TRUE(test, refcount_dec_and_test(&r));
    KUNIT_EXPECT_EQ(test, refcount_read(&r), 0);
}

static void test_refcount_inc_not_zero(struct kunit *test)
{
    refcount_t r = REFCOUNT_INIT(1);

    /* 정상: 1에서 inc_not_zero → 성공 */
    KUNIT_EXPECT_TRUE(test, refcount_inc_not_zero(&r));
    KUNIT_EXPECT_EQ(test, refcount_read(&r), 2);

    /* 0으로 만든 후 inc_not_zero → 실패 */
    refcount_dec_and_test(&r);  /* 2→1 */
    refcount_dec_and_test(&r);  /* 1→0 */
    KUNIT_EXPECT_FALSE(test, refcount_inc_not_zero(&r));
}

static void test_kref_lifecycle(struct kunit *test)
{
    struct {
        struct kref kref;
        bool released;
    } obj = { .released = false };

    kref_init(&obj.kref);
    KUNIT_EXPECT_EQ(test, refcount_read(&obj.kref.refcount), 1);

    kref_get(&obj.kref);
    KUNIT_EXPECT_EQ(test, refcount_read(&obj.kref.refcount), 2);

    /* 첫 번째 put — 아직 해제 안 됨 */
    kref_put(&obj.kref, ({
        void release(struct kref *k) {
            container_of(k, typeof(obj), kref)->released = true;
        }
        release;
    }));
    KUNIT_EXPECT_FALSE(test, obj.released);

    /* 두 번째 put — 해제됨 */
    KUNIT_EXPECT_TRUE(test, obj.released == false);
}

static struct kunit_case refcount_test_cases[] = {
    KUNIT_CASE(test_refcount_init),
    KUNIT_CASE(test_refcount_inc_dec),
    KUNIT_CASE(test_refcount_inc_not_zero),
    KUNIT_CASE(test_kref_lifecycle),
    {},
};

static struct kunit_suite refcount_test_suite = {
    .name = "refcount",
    .test_cases = refcount_test_cases,
};
kunit_test_suite(refcount_test_suite);

스트레스 테스트 접근법

/*
 * 멀티스레드 참조 카운팅 스트레스 테스트
 * 여러 kthread가 동시에 get/put을 수행하여
 * race condition을 유발합니다.
 */
static int stress_thread(void *data)
{
    struct my_item *item;
    int i;

    for (i = 0; i < 100000; i++) {
        /* RCU 기반 lookup */
        item = find_item_by_id(0);
        if (item) {
            /* 약간의 작업 시뮬레이션 */
            cpu_relax();
            /* 참조 해제 */
            item_put(item);
        }

        if (kthread_should_stop())
            break;

        /* 가끔 스케줄링 양보 */
        if ((i % 1000) == 0)
            cond_resched();
    }

    return 0;
}

/* 테스트 실행: 4개 스레드 동시 get/put */
static void run_stress_test(void)
{
    struct task_struct *threads[4];
    int i;

    for (i = 0; i < 4; i++)
        threads[i] = kthread_run(stress_thread, NULL, "reftest/%d", i);

    msleep(5000);  /* 5초 실행 */

    for (i = 0; i < 4; i++)
        kthread_stop(threads[i]);

    /*
     * 테스트 완료 후 refcount가 1(초기 참조만)이면 성공.
     * KASAN이나 refcount_t WARN이 발생하지 않아야 합니다.
     */
}

완전한 모듈 예제

kref를 사용하는 완전한 커널 모듈 예제입니다. RCU 기반 lookup, workqueue 통합, sysfs 속성을 포함합니다.

/*
 * kref_example.c — kref 참조 카운팅 예제 모듈
 * 커널 5.15+ 대상
 */
#include <linux/module.h>
#include <linux/kref.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/rculist.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>
#include <linux/debugfs.h>

#define MAX_ITEMS 16

struct my_item {
    struct kref        kref;
    struct list_head   list;
    struct rcu_head    rcu;
    struct work_struct work;
    int                id;
    char               data[64];
};

static LIST_HEAD(item_list);
static DEFINE_SPINLOCK(item_lock);
static int next_id;
static struct dentry *dbgdir;

/* ── release 콜백 ── */
static void item_release(struct kref *kref)
{
    struct my_item *item = container_of(kref, struct my_item, kref);

    pr_info("kref_example: releasing item %d\n", item->id);
    kfree_rcu(item, rcu);  /* RCU grace period 후 kfree */
}

static inline void item_put(struct my_item *item)
{
    kref_put(&item->kref, item_release);
}

static inline struct my_item *item_get(struct my_item *item)
{
    if (item)
        kref_get(&item->kref);
    return item;
}

/* ── RCU 기반 lookup ── */
static struct my_item *find_item_by_id(int id)
{
    struct my_item *item;

    rcu_read_lock();
    list_for_each_entry_rcu(item, &item_list, list) {
        if (item->id == id) {
            if (!kref_get_unless_zero(&item->kref))
                item = NULL;
            rcu_read_unlock();
            return item;
        }
    }
    rcu_read_unlock();
    return NULL;
}

/* ── 생성/삭제 ── */
static struct my_item *create_item(const char *data)
{
    struct my_item *item;

    item = kzalloc(sizeof(*item), GFP_KERNEL);
    if (!item)
        return NULL;

    kref_init(&item->kref);
    strscpy(item->data, data, sizeof(item->data));

    spin_lock(&item_lock);
    item->id = next_id++;
    list_add_tail_rcu(&item->list, &item_list);
    spin_unlock(&item_lock);

    pr_info("kref_example: created item %d '%s'\n", item->id, item->data);
    return item;
}

static void remove_item(struct my_item *item)
{
    spin_lock(&item_lock);
    list_del_rcu(&item->list);
    spin_unlock(&item_lock);

    /* 리스트 참조 해제 — 다른 holder가 없으면 kfree_rcu */
    item_put(item);
}

/* ── workqueue 연동 ── */
static void item_work_fn(struct work_struct *work)
{
    struct my_item *item = container_of(work, struct my_item, work);

    pr_info("kref_example: processing item %d '%s'\n",
            item->id, item->data);

    /* 작업 완료 후 참조 해제 */
    item_put(item);
}

static void schedule_item_work(struct my_item *item)
{
    item_get(item);  /* workqueue용 참조 */
    INIT_WORK(&item->work, item_work_fn);
    if (!queue_work(system_wq, &item->work))
        item_put(item);  /* 큐 실패 시 되돌림 */
}

/* ── debugfs 인터페이스 ── */
static int items_show(struct seq_file *m, void *v)
{
    struct my_item *item;

    rcu_read_lock();
    list_for_each_entry_rcu(item, &item_list, list) {
        seq_printf(m, "id=%d data='%s' refcount=%u\n",
                   item->id, item->data,
                   refcount_read(&item->kref.refcount));
    }
    rcu_read_unlock();
    return 0;
}
DEFINE_SHOW_ATTRIBUTE(items);

/* ── 모듈 초기화/종료 ── */
static int __init kref_example_init(void)
{
    struct my_item *item1, *item2, *found;

    dbgdir = debugfs_create_dir("kref_example", NULL);
    debugfs_create_file("items", 0444, dbgdir, NULL, &items_fops);

    /* 아이템 생성 */
    item1 = create_item("hello");
    item2 = create_item("world");

    /* RCU lookup으로 참조 획득 */
    found = find_item_by_id(0);
    if (found) {
        pr_info("found item: %s (refcount=%u)\n",
                found->data, refcount_read(&found->kref.refcount));
        schedule_item_work(found);
        item_put(found);  /* lookup 참조 해제 */
    }

    pr_info("kref_example: module loaded\n");
    return 0;
}

static void __exit kref_example_exit(void)
{
    struct my_item *item, *tmp;

    debugfs_remove_recursive(dbgdir);

    /* 모든 아이템 제거 */
    spin_lock(&item_lock);
    list_for_each_entry_safe(item, tmp, &item_list, list) {
        list_del_rcu(&item->list);
        item_put(item);
    }
    spin_unlock(&item_lock);

    /* RCU grace period 대기하여 모든 참조 해제 보장 */
    synchronize_rcu();
    flush_scheduled_work();

    pr_info("kref_example: module unloaded\n");
}

module_init(kref_example_init);
module_exit(kref_example_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("kref reference counting example");
MODULE_AUTHOR("Linux Kernel Docs");

refcount_t 내부 구현 아키텍처별 비교

refcount_t의 핵심 함수인 refcount_dec_and_test는 아키텍처마다 서로 다른 원자적 명령어를 사용하여 구현됩니다. 각 아키텍처의 구현 방식은 성능 특성과 메모리 순서 보장에 직접적인 영향을 미칩니다.

x86: LOCK CMPXCHG 기반 구현

x86 아키텍처는 LOCK CMPXCHG(Compare and Exchange) 명령어를 사용하여 원자적 감소와 saturation 검사를 단일 연산으로 수행합니다. x86의 강한 메모리 모델(TSO, Total Store Order) 덕분에 추가적인 메모리 배리어가 거의 필요하지 않습니다.

/* arch/x86 — refcount_dec_and_test 내부 흐름 (개념적 의사 코드) */
static inline bool refcount_dec_and_test(refcount_t *r)
{
    int old, new;

    do {
        old = atomic_read(&r->refs);   /* 현재 값 읽기 */

        if (old == REFCOUNT_SATURATED)   /* 포화 상태면 아무것도 안 함 */
            return false;

        new = old - 1;

        if (new < 0) {                   /* 언더플로 감지 */
            refcount_warn_saturate(r, REFCOUNT_SUB_UAF);
            return false;
        }

    } while (!try_cmpxchg_release(&r->refs.counter, &old, new));
    /* x86: LOCK CMPXCHG — 버스 락으로 원자성 보장 */

    if (new == 0) {
        smp_acquire__after_ctrl_dep();  /* acquire 의미론 확보 */
        return true;                    /* 마지막 참조 → release 콜백 */
    }
    return false;
}

ARM64: LDXR/STXR(LL/SC) 및 LSE Atomics

ARM64는 기본적으로 LL/SC(Load-Link/Store-Conditional) 방식인 LDXR/STXR 명령어 쌍을 사용합니다. ARMv8.1-A 이후의 LSE(Large System Extensions) 확장이 있는 시스템에서는 CAS(Compare And Swap) 또는 LDADD 같은 단일 원자적 명령어를 사용하여 성능을 개선합니다.

/* ARM64 LL/SC 방식 의사 코드 */
refcount_dec_and_test:
    prfm    pstl1strm, [x0]        /* 캐시 라인 프리페치 (store 힌트) */
1:  ldxr    w1, [x0]               /* Exclusive Load: 현재 refcount 읽기 */
    sub     w2, w1, #1             /* 1 감소 */
    cbz     w1, 3f                 /* 이미 0이면 → 언더플로 경고 */
    stlxr   w3, w2, [x0]           /* Exclusive Store (release): 결과 쓰기 시도 */
    cbnz    w3, 1b                 /* 실패하면 재시도 (다른 코어가 개입) */
    cbz     w2, 2f                 /* 결과가 0이면 → 마지막 참조 */
    ret                             /* 아직 참조 남음 → return false */
2:  dmb     ish                    /* acquire 배리어: 후속 읽기 앞에 삽입 */
    /* return true */
    ret
3:  /* saturation / underflow 처리 */

/* ARMv8.1 LSE 방식 (CONFIG_ARM64_LSE_ATOMICS) */
refcount_dec_and_test_lse:
    mov     w1, #-1                /* 감소값 = -1 */
    ldaddl  w1, w2, [x0]           /* atomic: old = *x0; *x0 += w1 (release) */
    /* w2 = old value, 단일 명령어로 원자적 감소 완료 */
    cmp     w2, #1                 /* old가 1이었으면 → 0이 됨 → 마지막 참조 */
    b.eq    2f
    ret
2:  dmb     ish
    ret

RISC-V: LR/SC 기반

RISC-V는 LR(Load Reserved)/SC(Store Conditional) 쌍을 사용하며, AMO(Atomic Memory Operation) 확장을 통해 AMOADD 같은 명령어도 지원합니다. 메모리 순서는 .aq(acquire)와 .rl(release) 접미사로 명시적으로 지정합니다.

/* RISC-V LR/SC 방식 의사 코드 */
refcount_dec_and_test:
1:  lr.w    a1, (a0)               /* Load Reserved: refcount 읽기 */
    addi    a2, a1, -1             /* 1 감소 */
    beqz    a1, 3f                 /* 이미 0이면 → 언더플로 */
    sc.w.rl a3, a2, (a0)            /* Store Conditional (release) */
    bnez    a3, 1b                 /* SC 실패 → 재시도 */
    beqz    a2, 2f                 /* 결과 0 → 마지막 참조 */
    li      a0, 0                  /* return false */
    ret
2:  fence   r, rw                  /* acquire 배리어 */
    li      a0, 1                  /* return true */
    ret
3:  /* saturation 처리 */

/* RISC-V AMO 확장 사용 시 */
refcount_dec_and_test_amo:
    li      a1, -1
    amoadd.w.rl a2, a1, (a0)        /* atomic: old = *a0; *a0 += a1 (release) */
    li      a3, 1
    bne     a2, a3, 1f             /* old != 1 → 아직 참조 남음 */
    fence   r, rw                  /* acquire */
    li      a0, 1
    ret
1:  li      a0, 0
    ret

아키텍처별 성능 특성 비교

참조 카운터 기반 객체 생명주기 시나리오

참조 카운팅의 실제 동작을 이해하기 위해, 커널 내 대표적인 세 가지 서브시스템에서 참조 카운터가 객체 생명주기를 어떻게 관리하는지 살펴봅니다.

시나리오 1: 네트워크 소켓 (struct sock)

네트워크 소켓 struct sock은 sk_refcnt 필드(refcount_t)를 통해 참조 카운팅됩니다. 소켓은 사용자 공간 프로세스, 타이머, 네트워크 스택의 여러 계층에서 동시에 참조될 수 있으므로, 정확한 참조 카운팅이 필수적입니다.

/* include/net/sock.h */
struct sock {
    /* ... 수백 개의 필드 ... */
    refcount_t      sk_refcnt;           /* 소켓 참조 카운터 */
    /* ... */
};

/* 참조 획득: sock_hold */
static inline void sock_hold(struct sock *sk)
{
    refcount_inc(&sk->sk_refcnt);
}

/* 참조 해제: sock_put */
void sock_put(struct sock *sk)
{
    if (refcount_dec_and_test(&sk->sk_refcnt))
        sk_free(sk);           /* 마지막 참조 → proto->destroy() + kfree */
}

/* TCP 연결 수립 시 참조 흐름 예시 */
struct sock *tcp_v4_syn_recv_sock(...)
{
    struct sock *newsk = tcp_create_openreq_child(sk, req, skb);
    /* newsk->sk_refcnt = 1 (생성자 참조) */

    inet_ehash_nolisten(newsk, osk, ...);
    /* 해시 테이블 삽입 — 별도의 sock_hold 불필요 (생성자 참조 이전) */

    return newsk;
}

/* 타이머에서의 참조 획득/해제 */
static void tcp_keepalive_timer(struct timer_list *t)
{
    struct sock *sk = from_timer(sk, t, sk_timer);

    bh_lock_sock(sk);
    /* ... keepalive 처리 ... */
    bh_unlock_sock(sk);
    sock_put(sk);   /* 타이머 콜백 완료 → 참조 해제 */
}

시나리오 2: 파일 디스크립터 (struct file)

struct file은 f_count 필드(atomic_long_t)를 통해 참조 카운팅됩니다. 하나의 파일을 여러 프로세스가 공유(fork, dup)하거나, 동일 프로세스 내 여러 스레드가 접근할 수 있으므로 정확한 참조 관리가 필수적입니다.

/* include/linux/fs.h */
struct file {
    union {
        struct llist_node f_llist;
        struct rcu_head  f_rcuhead;
    };
    struct path        f_path;
    struct inode       *f_inode;
    const struct file_operations *f_op;
    atomic_long_t     f_count;     /* 참조 카운터 */
    /* ... */
};

/* 참조 획득: fget (fd 테이블에서 struct file 획득) */
struct file *fget(unsigned int fd)
{
    struct file *file;

    rcu_read_lock();
    file = fcheck_files(current->files, fd);
    if (file) {
        if (!atomic_long_inc_not_zero(&file->f_count)) {
            /* f_count가 이미 0 → 파일이 닫히는 중 */
            file = NULL;
        }
    }
    rcu_read_unlock();
    return file;
}

/* 참조 해제: fput */
void fput(struct file *file)
{
    if (atomic_long_dec_and_test(&file->f_count)) {
        struct task_struct *task = current;

        if (likely(!in_interrupt() && !(task->flags & PF_KTHREAD))) {
            init_task_work(&file->f_rcuhead, ____fput);
            task_work_add(task, &file->f_rcuhead, TWA_RESUME);
        } else {
            /* 인터럽트/커널 스레드: 지연 해제 */
            llist_add(&file->f_llist, &delayed_fput_list);
            schedule_delayed_work(&delayed_fput_work, 1);
        }
    }
}

/* fork 시 참조 공유 */
struct file *get_file(struct file *f)
{
    atomic_long_inc(&f->f_count);     /* 자식 프로세스도 같은 file 참조 */
    return f;
}

시나리오 3: 디바이스 모델 (struct device)

struct device는 내부에 struct kobject를 포함하고, kobject 내부의 struct kref를 통해 참조 카운팅됩니다. device_get/device_put 대신 get_device/put_device를 사용하며, 이는 kobject_get/kobject_put의 래퍼입니다.

/* include/linux/device.h */
struct device {
    struct kobject kobj;       /* kobject → kref → refcount_t */
    struct device  *parent;
    struct bus_type *bus;
    struct device_driver *driver;
    void           *driver_data;
    /* ... */
};

/* 참조 획득: get_device */
struct device *get_device(struct device *dev)
{
    return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;
    /* kobject_get → kref_get → refcount_inc */
}

/* 참조 해제: put_device */
void put_device(struct device *dev)
{
    if (dev)
        kobject_put(&dev->kobj);
    /* kobject_put → kref_put → refcount_dec_and_test
     * → 0이 되면 kobject_release → device_release */
}

/* 드라이버 probe/remove 흐름 */
static int really_probe(struct device *dev, struct device_driver *drv)
{
    get_device(dev);           /* 드라이버 바인딩 전 참조 획득 */

    int ret = call_driver_probe(dev, drv);
    if (ret) {
        put_device(dev);       /* probe 실패 → 참조 해제 */
        return ret;
    }
    /* 성공: dev->driver = drv, 참조 유지 */
    return 0;
}

/* sysfs에서 디바이스 속성 읽기 시 */
static ssize_t dev_attr_show(struct kobject *kobj,
                             struct attribute *attr, char *buf)
{
    struct device *dev = kobj_to_dev(kobj);
    /* kobj 참조가 sysfs에 의해 보장됨 — 별도 get_device 불필요 */
    return dev_attr->show(dev, dev_attr, buf);
}

참조 카운터 디버깅 실전

참조 카운팅 버그는 커널에서 가장 찾기 어려운 버그 유형 중 하나입니다. UAF(Use-After-Free), 이중 해제(Double Free), 참조 누수(Leak) 등의 문제를 진단하기 위한 실전 디버깅 기법을 다룹니다.

KASAN을 이용한 UAF 탐지

KASAN(Kernel Address Sanitizer)은 해제된 메모리에 대한 접근을 실시간으로 탐지합니다. CONFIG_KASAN=y로 빌드된 커널에서는 참조 카운팅 실수로 인한 UAF가 즉시 보고됩니다.

==================================================================
BUG: KASAN: slab-use-after-free in my_device_read+0x48/0x120
Read of size 8 at addr ffff888012345678 by task cat/1234

CPU: 2 PID: 1234 Comm: cat Not tainted 6.8.0-debug #1
Hardware name: QEMU Standard PC (Q35)
Call Trace:
 dump_stack_lvl+0x48/0x70
 print_report+0xd2/0x620
 kasan_report+0xda/0x110
 my_device_read+0x48/0x120       ← UAF 발생 위치
 vfs_read+0x1a2/0x790
 ksys_read+0xf1/0x1c0
 do_syscall_64+0x5d/0x90

Allocated by task 567:                     ← 메모리가 할당된 경로
 kasan_save_stack+0x33/0x60
 kmalloc_trace+0x25/0x90
 my_device_create+0x2a/0x180     ← 객체 생성 위치
 driver_probe+0x42/0x1e0

Freed by task 890:                         ← 메모리가 해제된 경로
 kasan_save_stack+0x33/0x60
 kasan_save_free_info+0x27/0x40
 kfree+0xef/0x380
 my_device_release+0x35/0x60     ← kref_put 콜백에서 해제
 kref_put+0x3a/0x60
 my_device_close+0x28/0x40       ← close()에서 참조 해제

The buggy address belongs to the object at ffff888012345600
 which belongs to the cache kmalloc-256 of size 256
The buggy address is located 120 bytes inside of
 freed 256-byte region [ffff888012345600, ffff888012345700)
==================================================================

KASAN 보고서에서 확인해야 할 핵심 정보는 다음과 같습니다.

refcount_t saturation WARN 해석

refcount_t는 오버플로/언더플로를 감지하면 값을 REFCOUNT_SATURATED(0xC0000000)로 고정하고 WARN을 출력합니다. 이 경고가 발생하면 참조 카운팅에 심각한 버그가 있음을 의미합니다.

refcount_t: addition on 0; use-after-free.
WARNING: CPU: 1 PID: 2345 at lib/refcount.c:25 refcount_warn_saturate+0xba/0x110
Modules linked in: my_driver(OE)
CPU: 1 PID: 2345 Comm: worker/1:2 Tainted: G    OE     6.8.0 #1
Call Trace:
 refcount_warn_saturate+0xba/0x110
 refcount_inc+0x4e/0x60           ← refcount가 0인 상태에서 inc 시도
 kref_get+0x1c/0x30
 my_device_work_handler+0x22/0x80 ← 이미 해제된 객체의 kref_get
 process_one_work+0x2a2/0x620
 worker_thread+0x52/0x3f0

--- 또 다른 경우: 언더플로 ---
refcount_t: underflow; use-after-free.
WARNING: CPU: 3 PID: 3456 at lib/refcount.c:28 refcount_warn_saturate+0xce/0x110
Call Trace:
 refcount_warn_saturate+0xce/0x110
 refcount_dec_and_test+0xb8/0xd0  ← 이미 0인 refcount를 또 감소
 kref_put+0x3a/0x60
 my_device_cleanup+0x40/0x60     ← 이중 kref_put 호출

ftrace를 이용한 kref_get/kref_put 추적

ftrace의 function tracer를 사용하면 특정 객체의 kref_get/kref_put 호출 경로를 실시간으로 추적할 수 있습니다.

# ftrace로 kref 관련 함수 추적 설정
cd /sys/kernel/debug/tracing

# 추적 대상 함수 설정
echo 'kref_get kref_put kref_get_unless_zero' > set_ftrace_filter
echo '1' > options/func_stack_trace    # 호출 스택도 기록
echo 'function' > current_tracer

# 추적 시작
echo 1 > tracing_on

# ... 문제 재현 ...

# 추적 중지 및 결과 확인
echo 0 > tracing_on
cat trace

# 출력 예시:
#              TASK-PID   CPU#  |  TIMESTAMP  FUNCTION
#                 |  |      |   |      |         |
#           cat-1234  [002]  d..1  1234.567890: kref_get <-my_device_open
#           cat-1234  [002]  d..1  1234.567891: <stack trace>
#  => kref_get
#  => my_device_open
#  => chrdev_open
#  => do_dentry_open
#  => vfs_open

# 특정 모듈의 함수만 필터링하여 추적
echo ':mod:my_driver' > set_ftrace_filter
echo 'kref_get kref_put' >> set_ftrace_filter

# kprobe로 refcount 값까지 추적
echo 'p:kprobe/kref_get_trace kref_get kref=%di +0(%di):u32' > kprobe_events
echo 1 > events/kprobes/kref_get_trace/enable

slabinfo와 참조 누수 연관 분석

/proc/slabinfo를 모니터링하면 참조 카운트 누수로 인한 메모리 증가를 감지할 수 있습니다. 특정 slab 캐시의 활성 객체 수가 지속적으로 증가하면 참조 누수를 의심해야 합니다.

# slab 캐시별 활성 객체 수 모니터링
watch -n 5 'cat /proc/slabinfo | head -2; cat /proc/slabinfo | grep -E "kmalloc-256|sock_inode_cache|dentry"'

# 출력 예시 (active_objs가 시간이 지남에 따라 단조 증가하면 누수 의심):
# slabinfo - version: 2.1
# # name           <active_objs> <num_objs> <objsize> ...
# kmalloc-256          1847       2048     256    ...
# sock_inode_cache      342        380     832    ...
# dentry              28450      29184     192    ...

# slabinfo 변화량 추적 스크립트
for i in $(seq 1 10); do
    echo "=== Sample $i ==="
    grep 'my_device_cache' /proc/slabinfo | awk '{print $1, "active="$2, "total="$3}'
    sleep 10
done

# slab_unreclaimable 증가도 누수 지표
cat /proc/meminfo | grep 'SUnreclaim'
# SUnreclaim:       45632 kB   ← 시간이 지남에 따라 증가하면 누수

# CONFIG_SLUB_DEBUG 활성화 시 상세 추적
echo 1 > /sys/kernel/slab/kmalloc-256/trace
# dmesg에서 할당/해제 추적 로그 확인

crash 도구로 refcount 상태 확인

시스템 크래시 덤프(vmcore)에서 crash 도구를 사용하여 객체의 refcount 상태를 직접 확인할 수 있습니다.

# crash 도구 실행
crash vmlinux vmcore

# 특정 구조체의 refcount 확인
crash> struct kobject ffff888012345600
  kobj = {
    name = "my_device0",
    kref = {
      refcount = {
        refs = {
          counter = 0          ← refcount가 0 (이미 해제됨)
        }
      }
    },
    ...
  }

# struct device의 refcount 확인
crash> struct device.kobj.kref ffff888012345600
  kobj.kref = {
    refcount = {
      refs = {
        counter = -1073741824  ← 0xC0000000 = REFCOUNT_SATURATED
      }
    }
  }

# sock 구조체의 sk_refcnt 확인
crash> struct sock.sk_refcnt ffff888087654300
  sk_refcnt = {
    refs = {
      counter = 2              ← 아직 2개의 참조가 존재
    }
  }

# 메모리 슬랩 정보 확인
crash> kmem ffff888012345600
  CACHE             OBJSIZE  ALLOCATED  TOTAL  SLABS
  kmalloc-256          256      1847   2048    128
  SLAB              MEMORY         NODE  TOTAL  ALLOCATED  FREE
  ffffea0000048d00  ffff888012340000    0     16        14     2
    ffff888012345600  (free)           ← 이미 해제된 상태

# list에 연결된 모든 device의 refcount 확인
crash> list device.kobj.entry -s device.kobj.kref.refcount.refs.counter -H ffff888000100000

percpu_ref 심층

percpu_ref는 읽기 경로(참조 획득/해제)의 성능이 극도로 중요한 경우를 위해 설계된 고성능 참조 카운터입니다. 일반 모드에서는 per-CPU 변수를 사용하여 캐시 바운싱 없이 참조 카운팅을 수행하고, 셧다운(kill) 시에는 단일 atomic 카운터 모드로 전환하여 정확한 0 검사를 수행합니다.

struct percpu_ref 구조

/* include/linux/percpu-refcount.h */
struct percpu_ref {
    atomic_long_t       count;            /* atomic 카운터 (kill 후 사용) */
    unsigned long       percpu_count_ptr; /* per-CPU 카운터 포인터 + 플래그 */
    percpu_ref_func_t  *release;          /* 참조 0 시 콜백 */
    percpu_ref_func_t  *confirm_switch;   /* 모드 전환 완료 콜백 */
    struct rcu_head     rcu;              /* RCU 콜백용 */
};

/* 핵심 API */
int  percpu_ref_init(struct percpu_ref *ref,
                     percpu_ref_func_t *release,
                     unsigned int flags, struct gfp_t gfp);

static inline void percpu_ref_get(struct percpu_ref *ref)
{
    unsigned long __percpu *percpu_count;

    rcu_read_lock_sched();

    if (__ref_is_percpu(ref, &percpu_count))
        this_cpu_inc(*percpu_count);    /* per-CPU 모드: 로컬 CPU 카운터++ */
    else
        atomic_long_inc(&ref->count);  /* atomic 모드: 단일 카운터++ */

    rcu_read_unlock_sched();
}

static inline void percpu_ref_put(struct percpu_ref *ref)
{
    unsigned long __percpu *percpu_count;

    rcu_read_lock_sched();

    if (__ref_is_percpu(ref, &percpu_count))
        this_cpu_dec(*percpu_count);    /* per-CPU 모드: 로컬 CPU 카운터-- */
    else if (unlikely(atomic_long_dec_and_test(&ref->count)))
        ref->release(ref);              /* atomic 모드에서 0이 되면 release */

    rcu_read_unlock_sched();
}

/* 셧다운: per-CPU → atomic 전환 */
void percpu_ref_kill(struct percpu_ref *ref)
{
    percpu_ref_kill_and_confirm(ref, NULL);
}

percpu_ref 활용 사례

percpu_ref는 I/O 경로처럼 초고속 참조 카운팅이 필요하면서도, 셧다운 시 정확한 drain이 보장되어야 하는 서브시스템에서 사용됩니다.

/* block/blk-mq.c — blk-mq의 q_usage_counter */
struct request_queue {
    /* ... */
    struct percpu_ref  q_usage_counter;  /* I/O 요청 진행 중 카운터 */
    /* ... */
};

/* I/O 제출 경로: 매우 빈번하게 호출됨 */
blk_status_t blk_mq_submit_bio(struct bio *bio)
{
    struct request_queue *q = bdev_get_queue(bio->bi_bdev);

    if (!percpu_ref_tryget_live(&q->q_usage_counter)) {
        /* 큐가 freeze 중 → I/O 거부 */
        bio_io_error(bio);
        return BLK_STS_IOERR;
    }

    /* ... I/O 처리 ... */

    percpu_ref_put(&q->q_usage_counter);
    return BLK_STS_OK;
}

/* 큐 freeze: 진행 중인 모든 I/O가 완료될 때까지 대기 */
void blk_freeze_queue(struct request_queue *q)
{
    percpu_ref_kill(&q->q_usage_counter);
    /* per-CPU → atomic 전환 후 */

    blk_mq_run_hw_queues(q, false);
    wait_event(q->mq_freeze_wq,
              percpu_ref_is_zero(&q->q_usage_counter));
    /* 모든 I/O 완료 → 큐 안전하게 변경 가능 */
}

/* cgroup에서의 활용: cgroup_file에 percpu_ref 사용 */
struct cgroup {
    /* ... */
    struct percpu_ref self;   /* cgroup 자체 참조 카운터 */
    /* ... */
};

lockref 최적화 패턴

lockref는 spinlock과 참조 카운트를 하나의 8바이트(64비트) 값에 패킹하여, cmpxchg 한 번으로 잠금 없이 참조 카운트를 변경하는 최적화 기법입니다. 주로 dentry 캐시에서 사용되며, 경로 탐색(path lookup) 성능을 크게 향상시킵니다.

struct lockref 구조

/* include/linux/lockref.h */
struct lockref {
    union {
#if defined(CONFIG_ARCH_USE_CMPXCHG_LOCKREF)
        aligned_u64 lock_count;    /* cmpxchg용: lock + count를 한 번에 */
#endif
        struct {
            spinlock_t lock;           /* 4바이트 spinlock */
            int        count;          /* 4바이트 참조 카운트 */
        };
    };
};

/* dentry에서의 사용 */
struct dentry {
    struct lockref     d_lockref;  /* spinlock + refcount */
    struct inode       *d_inode;
    struct hlist_bl_node d_hash;
    struct dentry      *d_parent;
    struct qstr        d_name;
    /* ... */
};

/* lockref_get: fast path (cmpxchg) → slow path (spinlock) */
void lockref_get(struct lockref *lockref)
{
    CMPXCHG_LOOP(
        new.count++;              /* 시도: count만 1 증가 */
    ,
        return;                   /* cmpxchg 성공 → 바로 리턴 */
    );

    /* cmpxchg 실패 (lock 경합) → slow path */
    spin_lock(&lockref->lock);
    lockref->count++;
    spin_unlock(&lockref->lock);
}

/* lockref_put_return: 감소 후 count 반환 */
int lockref_put_return(struct lockref *lockref)
{
    CMPXCHG_LOOP(
        new.count--;
        if (old.count <= 0)       /* 이미 0 이하면 slow path */
            break;
    ,
        return new.count;
    );
    return -1;                    /* slow path 필요 */
}

/* lockref_get_not_dead: count > 0인 경우만 획득 */
int lockref_get_not_dead(struct lockref *lockref)
{
    CMPXCHG_LOOP(
        new.count++;
        if (old.count < 0)        /* 음수면 "dead" → 실패 */
            return 0;
    ,
        return 1;                  /* 성공 */
    );

    spin_lock(&lockref->lock);
    int retval = 0;
    if (lockref->count >= 0) {
        lockref->count++;
        retval = 1;
    }
    spin_unlock(&lockref->lock);
    return retval;
}

dentry 캐시에서의 성능 효과

lockref가 dentry 캐시 성능에 미치는 영향은 상당합니다. 경로 탐색(path lookup)의 각 컴포넌트에서 dentry의 참조를 획득/해제해야 하므로, 디렉토리 깊이가 깊을수록 lockref의 fast path가 더 큰 성능 이점을 제공합니다.

/* fs/dcache.c — dget (dentry 참조 획득) */
static inline struct dentry *dget(struct dentry *dentry)
{
    if (dentry)
        lockref_get(&dentry->d_lockref);
    /* fast path: cmpxchg 1회 → spinlock 없이 완료 */
    return dentry;
}

/* fs/dcache.c — dput (dentry 참조 해제) */
void dput(struct dentry *dentry)
{
    if (!dentry)
        return;

    /* fast path: count > 1이면 spinlock 없이 감소 */
    if (lockref_put_return(&dentry->d_lockref) > 0)
        return;               /* 아직 참조 남음 → 바로 리턴 */

    /* slow path: count가 0이 될 수 있음 → spinlock으로 보호 */
    dput_to_list(dentry, &list);
}

/* RCU path walk에서의 lockref 사용 */
static inline int d_revalidate(struct dentry *dentry, unsigned int flags)
{
    if (flags & LOOKUP_RCU) {
        /* RCU walk: lockref_get_not_dead로 dentry 유효성 검증 */
        if (!lockref_get_not_dead(&dentry->d_lockref))
            return -ECHILD;   /* dead dentry → ref walk로 전환 */
    }
    /* ... */
}

참고 자료

• 커널 문서: Documentation/core-api/kref.rst — kref API 공식 가이드
• 커널 문서: Documentation/core-api/refcount-vs-atomic.rst — refcount_t와 atomic_t 비교
• 헤더: include/linux/kref.h — kref 구조체 및 API 정의
• 헤더: include/linux/refcount.h — refcount_t 타입 및 인라인(Inline) API
• 구현: lib/refcount.c — saturation 보호 로직 구현
• 헤더: include/linux/kobject.h — kobject 구조체 (kref 사용)
• 구현: lib/kobject.c — kobject_get/kobject_put/kobject_release
• 헤더: include/linux/percpu-refcount.h — percpu_ref 고성능 참조 카운터
• Coccinelle: scripts/coccinelle/api/atomic_as_refcounter.cocci
• CVE-2016-0728: Perception Point, "Analysis and Exploitation of a Linux Kernel Vulnerability (CVE-2016-0728)", 2016
• Peter Zijlstra, Elena Reshetova, "refcount_t API compared to atomic_t", LWN.net (2017)
• Jonathan Corbet, "Bringing refcount_t to the mainline", LWN.net (2017)

관련 문서

kref/refcount_t와 관련된 다른 주제를 더 깊이 이해하고 싶다면 다음 문서를 참고하세요.

• Atomic 연산 — atomic_t, cmpxchg, 메모리 순서 의미론
• 메모리 배리어 — acquire/release, 아키텍처별 메모리 모델
• 커널 오브젝트 (kobject) — kobject, kset, sysfs 연동, 디바이스 모델
• RCU (Read-Copy-Update) — 잠금 없는 읽기 경로 동기화
• 동기화 기법 — 전체 동기화 프리미티브 비교 및 선택 가이드
• 메모리 관리 개요 — Buddy/Slab 할당자, kmalloc/kfree 메커니즘
• Lockdep — 잠금 의존성 그래프, 순환 탐지
• 동시성 디버깅 — KCSAN, lockdep, perf lock 통합 가이드
• 커널 개발 주의사항 — 흔한 실수와 방지
• sk_buff 구조 — 네트워크 패킷 참조 카운팅