커널 스레드 (Kernel Threads)

커널 스레드(kthread)는 유저 주소 공간(Address Space) 없이 커널 문맥에서 동작하는 핵심 실행 단위입니다. 이 문서는 kthreadd(PID 2) 기반 생성 흐름, kthread_create/run/stop/park 제어 API, kthread_worker 패턴, per-CPU 및 smpboot 스레드(Thread) 설계, freezer/CPU hotplug 대응, ksoftirqd/kworker/kswapd 운영 특성까지 실전 관점으로 상세히 설명합니다.

개요 (Overview)

리눅스에서 커널 스레드는 유저 공간 주소 공간 없이 커널 모드에서만 동작하는 태스크입니다. 일반 유저 프로세스와 동일하게 task_struct로 표현되지만, 핵심적인 차이가 있습니다:

시스템 계층에서의 위치

커널 스레드는 항상 커널 공간(Kernel Space)에서만 실행됩니다. 유저 프로세스가 시스템 콜(System Call)을 통해 커널로 진입하는 것과 달리, 커널 스레드는 처음부터 커널 공간에 존재합니다:

왜 커널 스레드가 필요한가

커널 내부의 장기 실행 작업을 처리하는 방법들과 각각의 한계를 비교합니다:

커널 스레드가 필요한 대표적인 시나리오:

• 메모리 회수(Memory Reclaim) — kswapd: 페이지를 스캔하고 회수하는 데 수 밀리초가 걸립니다. 인터럽트 핸들러에서는 슬립할 수 없으므로 전용 스레드가 필수입니다.
• 비동기 I/O — kworker: 블록 디바이스 I/O 완료를 기다리며 슬립해야 할 때 커널 스레드가 대기합니다.
• Soft IRQ 부하 분산(Load Balancing) — ksoftirqd: 네트워크 패킷 폭주 시 softirq를 전담 스레드로 처리하여 인터럽트 레이턴시를 줄입니다.
• 파일시스템 저널링 — jbd2/sda1-8: 저널을 주기적으로 커밋하며 적절한 간격으로 슬립합니다.

유저 프로세스와의 속성 비교:

/* include/linux/sched.h - 커널 스레드 판별 */
static inline bool is_kthread(struct task_struct *p)
{
    return p->flags & PF_KTHREAD;
}

/* context_switch()에서의 Lazy TLB */
if (!next->mm) {
    /* 커널 스레드: 이전 태스크의 mm을 빌림 */
    next->active_mm = prev->active_mm;
    /* → TLB flush 불필요, 성능 향상 */
}

커널 스레드 메모리 모델 (Kernel Thread Memory Model)

커널 스레드는 일반 유저 프로세스와 달리 자체 유저 주소 공간이 없습니다. task_struct의 mm 필드가 NULL로 설정되어 있으며, 오직 커널 주소 공간(vmalloc, kmalloc, 직접 매핑(Mapping) 영역 등)만 접근할 수 있습니다.

mm과 active_mm의 관계

• mm == NULL: 커널 스레드는 자체 유저 주소 공간을 갖지 않습니다. 유저 공간 주소에 접근을 시도하면 page fault가 발생하고 커널 Oops로 이어집니다.
• active_mm: Lazy TLB 최적화를 위해 이전 태스크의 mm_struct를 빌려 사용합니다. 커널 주소 공간은 모든 프로세스의 페이지 테이블에 동일하게 매핑되어 있으므로, CR3 레지스터(Register)를 별도로 전환하지 않아도 커널 코드가 정상 동작합니다.
• 커널 주소 공간만 접근 가능: vmalloc(), kmalloc(), 직접 매핑 영역, 모듈 영역 등 커널 가상 주소(Virtual Address)만 사용할 수 있습니다.
• 유저 공간 접근 불가: copy_from_user(), get_user() 등을 호출하면 mm == NULL이므로 page fault가 발생하여 Oops/패닉(Panic)으로 이어집니다.

kthread_use_mm() / kthread_unuse_mm()

특수한 경우 커널 스레드에서 유저 공간에 접근해야 할 때 kthread_use_mm() / kthread_unuse_mm() API를 사용합니다. 이 API는 프로세스의 mm_struct를 일시적으로 빌려서 유저 주소 공간에 접근할 수 있게 합니다.

• io_uring: 커널 워커 스레드가 유저 버퍼(Buffer)에 직접 접근하여 비동기 I/O를 처리합니다.
• vhost: 가상화(Virtualization) 환경에서 호스트 커널 스레드가 게스트의 virtio 링 버퍼(Ring Buffer)에 접근합니다.
• NFS: 커널 NFS 데몬이 클라이언트 프로세스의 버퍼에 데이터를 직접 전달합니다.

사용 시 반드시 mmget()/mmput()으로 참조 카운트(Reference Count)를 관리해야 하며, 프로세스가 종료되어 mm_struct가 해제되는 것을 방지해야 합니다.

/* mm/mmu_context.c - kthread_use_mm() (간략화) */
void kthread_use_mm(struct mm_struct *mm)
{
    struct task_struct *tsk = current;

    WARN_ON_ONCE(!(tsk->flags & PF_KTHREAD));
    WARN_ON_ONCE(tsk->mm);

    mmgrab(mm);  /* mm_count 증가 */
    tsk->mm = mm;
    tsk->active_mm = mm;

    switch_mm_irqs_off(NULL, mm, tsk);  /* CR3 전환 */

    /* 이후 copy_from_user(), get_user() 등 유저 공간 접근 가능 */
}

void kthread_unuse_mm(struct mm_struct *mm)
{
    struct task_struct *tsk = current;

    tsk->mm = NULL;
    switch_mm_irqs_off(mm, &init_mm, tsk);

    mmdrop(mm);  /* mm_count 감소 */
}

/* 사용 예시 (vhost) */
static int vhost_worker(void *data)
{
    struct vhost_dev *dev = data;
    struct mm_struct *mm = dev->mm;

    kthread_use_mm(mm);

    while (!kthread_should_stop()) {
        /* 유저 공간의 vring 버퍼에 직접 접근 가능 */
        process_vring(dev);
        schedule();
    }

    kthread_unuse_mm(mm);
    return 0;
}

kthreadd (PID 2) — 커널 스레드 관리자

kthreadd는 부팅 초기에 rest_init()에서 생성되는 커널 스레드로, PID 2를 부여받습니다. 이후 생성되는 모든 커널 스레드의 부모 역할을 합니다.

/* init/main.c - rest_init() */
static void rest_init(void)
{
    /* PID 1: kernel_init → init/systemd */
    kernel_thread(kernel_init, NULL, CLONE_FS);

    /* PID 2: kthreadd — 커널 스레드 관리자 */
    pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
    kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);

    complete(&kthreadd_done);  /* kernel_init이 대기 중 */
    cpu_startup_entry(CPUHP_ONLINE);  /* idle 스레드가 됨 */
}

kthreadd 메인 루프

kthreadd()는 무한 루프에서 kthread_create_list를 감시하며, 새 커널 스레드 생성 요청을 처리합니다:

/* kernel/kthread.c - kthreadd() 메인 루프 (간략화) */
int kthreadd(void *unused)
{
    struct task_struct *tsk = current;

    /* 모든 시그널 차단 */
    set_cpus_allowed_ptr(tsk, housekeeping_cpumask(HK_TYPE_KTHREAD));
    ignore_signals(tsk);

    for (;;) {
        set_current_state(TASK_INTERRUPTIBLE);
        if (list_empty(&kthread_create_list))
            schedule();  /* 요청 없으면 슬립 */
        __set_current_state(TASK_RUNNING);

        while (!list_empty(&kthread_create_list)) {
            struct kthread_create_info *create;
            create = list_entry(kthread_create_list.next,
                        struct kthread_create_info, list);
            list_del_init(&create->list);

            /* 실제 커널 스레드 생성 */
            create_kthread(create);
        }
    }
    return 0;
}

생성 API

kthread_create()

kthread_create()는 커널 스레드를 생성하되, TASK_UNINTERRUPTIBLE 상태로 두어 아직 실행하지 않습니다. 호출자가 명시적으로 wake_up_process()를 호출해야 스레드가 실행됩니다.

/* include/linux/kthread.h */
struct task_struct *kthread_create(
    int (*threadfn)(void *data),  /* 스레드 함수 */
    void *data,                    /* 함수에 전달할 인자 */
    const char *namefmt, ...       /* 스레드 이름 (printf 형식) */
);

/* 사용 예시 */
struct task_struct *kth;
kth = kthread_create(my_thread_fn, my_data, "my-kthread/%d", cpu);
if (IS_ERR(kth)) {
    pr_err("kthread_create failed: %ld\n", PTR_ERR(kth));
    return PTR_ERR(kth);
}
/* CPU 바인딩 등 설정 후 시작 */
kthread_bind(kth, cpu);
wake_up_process(kth);

kthread_run()

kthread_run()은 kthread_create() + wake_up_process()를 합친 편의 매크로입니다:

/* include/linux/kthread.h */
#define kthread_run(threadfn, data, namefmt, ...)         \
({                                                          \
    struct task_struct *__k                              \
        = kthread_create(threadfn, data, namefmt,          \
                          ## __VA_ARGS__);                   \
    if (!IS_ERR(__k))                                     \
        wake_up_process(__k);                              \
    __k;                                                    \
})

/* 가장 흔한 사용법 */
struct task_struct *kth;
kth = kthread_run(my_thread_fn, NULL, "my-kthread");
if (IS_ERR(kth))
    return PTR_ERR(kth);

kthread_create_on_node() / kthread_create_on_cpu()

NUMA 노드 또는 특정 CPU에 바인딩된 커널 스레드를 생성합니다:

/* NUMA 노드 지정 생성 */
struct task_struct *kthread_create_on_node(
    int (*threadfn)(void *data),
    void *data, int node,
    const char *namefmt, ...
);

/* 특정 CPU 바인딩 생성 — per-CPU kthread에 사용 */
struct task_struct *kthread_create_on_cpu(
    int (*threadfn)(void *data),
    void *data, unsigned int cpu,
    const char *namefmt
);
/* → 자동으로 kthread_bind(task, cpu) + 이름에 CPU 번호 부여 */

내부 생성 흐름

/* kernel/kthread.c - create_kthread() 내부 (간략화) */
static void create_kthread(struct kthread_create_info *create)
{
    int pid;

    /* kernel_clone()으로 새 태스크 생성
     * → 새 태스크는 kthread() 함수에서 시작 */
    pid = kernel_thread(kthread, create, create->full_name,
                         CLONE_FS | CLONE_FILES | SIGCHLD);
    if (pid < 0) {
        create->result = ERR_PTR(pid);
        complete(&create->done);
    }
}

/* 새로 생성된 커널 스레드의 시작점 */
static int kthread(void *_create)
{
    struct kthread_create_info *create = _create;
    int (*threadfn)(void *data) = create->threadfn;
    void *data = create->data;
    int ret;

    /* 호출자에게 task_struct 포인터 전달 */
    create->result = current;
    complete(&create->done);

    /* wake_up_process()가 호출될 때까지 대기 */
    schedule_preempt_disabled();

    /* 스레드 함수 실행 */
    ret = threadfn(data);

    kthread_exit(ret);
}

커널 스레드 함수 패턴

기본 kthread_should_stop() 루프

가장 기본적인 커널 스레드 패턴입니다:

static int my_thread_fn(void *data)
{
    while (!kthread_should_stop()) {
        /* 작업 수행 */
        do_my_work(data);

        /* 일정 시간 슬립 */
        msleep_interruptible(1000);
    }
    return 0;
}

조건부 슬립(Sleep) 패턴 (set_current_state + schedule)

이벤트가 발생할 때만 깨어나는 효율적인 패턴입니다:

static int event_thread_fn(void *data)
{
    struct my_device *dev = data;

    while (!kthread_should_stop()) {
        /* ① 먼저 상태를 INTERRUPTIBLE로 설정 */
        set_current_state(TASK_INTERRUPTIBLE);

        /* ② 조건 확인 — 작업이 없으면 슬립 */
        if (!has_pending_work(dev)) {
            schedule();  /* CPU 양보, 깨워질 때까지 대기 */
            continue;
        }

        /* ③ 작업이 있으면 RUNNING으로 복원 후 처리 */
        __set_current_state(TASK_RUNNING);
        process_pending_work(dev);
    }
    __set_current_state(TASK_RUNNING);
    return 0;
}

/* 다른 곳에서 작업을 추가하고 스레드를 깨움 */
add_work(dev, new_work);
wake_up_process(thread_task);

Wakeup-miss 레이스 타임라인

아래 다이어그램은 잘못된 순서와 올바른 순서에서 두 스레드(T: 워커, W: 깨우기 담당)의 실행 흐름을 비교합니다:

wait_event_interruptible 패턴

위의 조건부 슬립을 더 안전하게 래핑한 API입니다:

static DECLARE_WAIT_QUEUE_HEAD(my_wq);
static bool work_pending = false;

static int waiter_thread_fn(void *data)
{
    while (!kthread_should_stop()) {
        /* 조건이 true가 되거나 kthread_stop()이 호출될 때까지 대기 */
        wait_event_interruptible(my_wq,
            work_pending || kthread_should_stop());

        if (kthread_should_stop())
            break;

        work_pending = false;
        do_work();
    }
    return 0;
}

/* 깨우기 */
work_pending = true;
wake_up_interruptible(&my_wq);

종료 API

kthread_stop()

kthread_stop()은 대상 커널 스레드에 종료 요청을 보내고, 스레드가 실제로 종료할 때까지 대기합니다:

/* kernel/kthread.c - kthread_stop() (간략화) */
int kthread_stop(struct task_struct *k)
{
    get_task_struct(k);  /* 참조 카운트 증가 */

    /* KTHREAD_SHOULD_STOP 플래그 설정 */
    kthread_set_bit(KTHREAD_SHOULD_STOP, k);

    /* 스레드가 슬립 중이면 깨움 */
    wake_up_process(k);

    /* 스레드가 종료할 때까지 대기 */
    wait_for_completion(&kthread->exited);

    ret = kthread->result;
    put_task_struct(k);  /* 참조 카운트 감소 */
    return ret;  /* 스레드 함수의 반환값 */
}

kthread_stop_put()

kthread_stop_put()은 kthread_stop()과 free_kthread_struct()을 하나로 합친 편의 API입니다. 스레드 종료 후 struct kthread 메타데이터를 즉시 해제하여 메모리 누수를 방지합니다:

/* include/linux/kthread.h */
int kthread_stop_put(struct task_struct *k);

/* 사용 예시: stop + 구조체 해제를 한 번에 */
kthread_stop_put(my_thread);

/* 위는 아래와 동등하지만 더 안전함 */
kthread_stop(my_thread);
free_kthread_struct(my_thread);

kthread_bind() / kthread_bind_mask() / kthread_affine_preferred()

커널 스레드의 CPU 어피니티(Affinity)를 제어하는 세 가지 API가 있습니다:

/* include/linux/kthread.h */

/* 단일 CPU에 강제 바인딩 — 미실행 상태에서만 호출 가능 */
void kthread_bind(struct task_struct *k, unsigned int cpu);

/* cpumask로 강제 바인딩 — 미실행 상태에서만 호출 가능 */
void kthread_bind_mask(struct task_struct *k, const struct cpumask *mask);

/* 실행 중인 스레드에 선호 어피니티 적용 — 런타임에도 가능 */
int kthread_affine_preferred(struct task_struct *p, const struct cpumask *mask);

kthread_park() / kthread_unpark()

커널 스레드를 일시 중지/재개하는 API입니다. CPU 핫플러그(Hotplug) 시 per-CPU 스레드를 관리하는 데 주로 사용됩니다:

/* 스레드 일시 중지 */
kthread_park(kth);
/* → 스레드 내부에서 kthread_should_park()가 true 반환
 * → 스레드는 kthread_parkme()에서 대기 상태로 진입 */

/* 스레드 재개 */
kthread_unpark(kth);
/* → KTHREAD_SHOULD_PARK 해제, 스레드 깨움 */

/* 스레드 함수 내에서 park 지원하기 */
static int parkable_thread_fn(void *data)
{
    while (!kthread_should_stop()) {
        /* park 요청이 있으면 대기 */
        if (kthread_should_park())
            kthread_parkme();

        do_work();
        schedule();
    }
    return 0;
}

커널 스레드 상태 전환

커널 스레드는 생성부터 종료까지 여러 상태를 거칩니다. 다음 다이어그램은 주요 상태 전환을 보여줍니다:

Per-CPU 커널 스레드

많은 커널 서브시스템이 각 CPU마다 전용 커널 스레드를 실행합니다. 대표적으로 ksoftirqd/N, migration/N, kworker/N:* 등이 있습니다. 이들은 캐시 지역성(Cache Locality) 극대화와 잠금 경합(Lock Contention) 완화를 위해 특정 CPU에 바인딩되며, smpboot 프레임워크가 이 스레드들의 생명주기를 CPU 핫플러그 이벤트에 맞춰 자동으로 관리합니다.

주요 per-CPU 스레드 역할 상세

smpboot 프레임워크

smpboot 프레임워크는 per-CPU 커널 스레드를 체계적으로 관리합니다. CPU 핫플러그(online/offline) 이벤트에 자동으로 대응하여 스레드를 생성/정지/재개합니다:

/* include/linux/smpboot.h */
struct smp_hotplug_thread {
    struct task_struct __percpu  **store;       /* per-CPU 태스크 포인터 */
    struct list_head             list;         /* 등록 리스트 */
    int                          (*thread_should_run)(unsigned int cpu);
    void                         (*thread_fn)(unsigned int cpu);
    void                         (*create)(unsigned int cpu);
    void                         (*setup)(unsigned int cpu);
    void                         (*cleanup)(unsigned int cpu, bool online);
    void                         (*park)(unsigned int cpu);
    void                         (*unpark)(unsigned int cpu);
    const char                   *thread_comm;  /* "ksoftirqd/%u" */
};

/* 등록 — 모든 online CPU에 대해 스레드 자동 생성 */
int smpboot_register_percpu_thread(struct smp_hotplug_thread *plug_thread);

/* 예: ksoftirqd 등록 (kernel/softirq.c) */
static struct smp_hotplug_thread softirq_threads = {
    .store              = &ksoftirqd,
    .thread_should_run  = ksoftirqd_should_run,
    .thread_fn          = run_ksoftirqd,
    .thread_comm        = "ksoftirqd/%u",
};

smpboot_thread_fn()이 per-CPU 스레드의 메인 루프를 실행합니다:

/* kernel/smpboot.c - smpboot_thread_fn() 핵심 (간략화) */
static int smpboot_thread_fn(void *data)
{
    struct smp_hotplug_thread *ht = data;
    unsigned int cpu = smp_processor_id();

    while (1) {
        set_current_state(TASK_INTERRUPTIBLE);

        if (kthread_should_park()) {
            __set_current_state(TASK_RUNNING);
            kthread_parkme();  /* CPU offline 시 park */
            continue;
        }

        if (!ht->thread_should_run(cpu)) {
            schedule();  /* 할 일 없으면 슬립 */
        } else {
            __set_current_state(TASK_RUNNING);
            ht->thread_fn(cpu);  /* 실제 작업 수행 */
        }

        if (kthread_should_stop())
            break;
    }
    return 0;
}

smpboot 프레임워크 아키텍처

smpboot은 CPU 핫플러그 이벤트와 per-CPU 스레드를 자동으로 연동합니다:

CPU affinity 관리

/* per-CPU 스레드의 CPU 바인딩 — kthread_bind()는 미실행 상태에서만 가능 */
void kthread_bind(struct task_struct *p, unsigned int cpu)
{
    __kthread_bind(p, cpumask_of(cpu), TASK_UNINTERRUPTIBLE);
}

/* 실행 중 스레드의 CPU 제한 */
set_cpus_allowed_ptr(current, cpumask_of(target_cpu));

/* NUMA 인식 per-CPU 스레드 — 같은 노드에서 메모리 할당 */
struct task_struct *t;
t = kthread_create_on_node(fn, data,
        cpu_to_node(cpu),  /* CPU가 속한 NUMA 노드 */
        "mythread/%d", cpu);
kthread_bind(t, cpu);
wake_up_process(t);

CPU Hotplug 연동 상세 (CPU Hotplug Integration)

Per-CPU 커널 스레드는 CPU 핫플러그 이벤트와 밀접하게 연동됩니다. smpboot 프레임워크는 cpuhp 상태 머신(State Machine)과 통합되어, CPU가 온라인/오프라인될 때 per-CPU 스레드의 생명주기를 자동으로 관리합니다.

CPU Online 과정

1. cpu_up() 호출로 cpuhp 상태 머신이 시작됩니다.
2. CPUHP_CREATE_THREADS 단계에서 smpboot이 해당 CPU의 per-CPU 스레드를 생성합니다 (이미 존재하면 생략).
3. kthread_unpark(): 파킹(Parked) 상태의 스레드를 깨워 실행 가능 상태로 전환합니다.
4. set_cpus_allowed_ptr(): 해당 CPU에 대한 affinity를 설정합니다.
5. wake_up_process(): 스레드 실행을 시작합니다.

CPU Offline 과정

1. cpu_down() 호출로 cpuhp 상태 머신이 시작됩니다.
2. sched_cpu_deactivate(): 해당 CPU에서 실행 중인 태스크를 다른 CPU로 마이그레이션합니다.
3. kthread_park(): per-CPU 스레드를 파킹 상태(TASK_PARKED)로 전환합니다.
4. 스레드는 살아있지만 TASK_PARKED 상태로 대기합니다. 스레드가 파괴되지 않으므로 CPU가 다시 온라인될 때 빠르게 재개할 수 있습니다.
5. CPU가 다시 온라인되면 kthread_unpark()로 스레드를 재개합니다.

/* kernel/smpboot.c - CPU hotplug 콜백 (간략화) */
static int smpboot_thread_fn(void *data)
{
    struct smp_hotplug_thread *ht = data;

    while (1) {
        set_current_state(TASK_INTERRUPTIBLE);
        preempt_disable();

        if (kthread_should_park()) {
            __set_current_state(TASK_RUNNING);
            preempt_enable();
            kthread_parkme();  /* TASK_PARKED로 진입 */
            continue;
        }

        if (!ht->thread_should_run(smp_processor_id())) {
            preempt_enable();
            schedule();
        } else {
            __set_current_state(TASK_RUNNING);
            preempt_enable();
            ht->thread_fn(smp_processor_id());
        }
    }
}

/* CPU hotplug 콜백 등록 예시 */
static struct smp_hotplug_thread my_threads = {
    .store             = &my_task_store,
    .thread_should_run = my_should_run,
    .thread_fn         = my_fn,
    .thread_comm       = "mythread/%u",
    .setup             = my_setup,     /* CPU online 시 호출 */
    .cleanup           = my_cleanup,   /* CPU offline 시 호출 */
    .park              = my_park,      /* park 시 호출 */
    .unpark            = my_unpark,    /* unpark 시 호출 */
};

smp_hotplug_thread 콜백(Callback) 함수

kthread vs 대안 선택 가이드

커널 내부 작업 처리에는 다양한 메커니즘이 있습니다. 아래 결정 트리를 참고하여 상황에 맞는 방식을 선택하세요:

kthread_worker API

kthread_worker는 workqueue의 경량 대안입니다. 전용 커널 스레드에서 작업(kthread_work)을 순차적으로 실행합니다. workqueue의 복잡한 동시성 관리가 필요 없고, 특정 스레드에서 작업을 보장해야 할 때 유용합니다.

/* include/linux/kthread.h */
struct kthread_worker {
    unsigned int        flags;
    struct list_head    work_list;      /* 대기 중인 작업 리스트 */
    struct list_head    delayed_work_list;
    struct task_struct  *task;          /* 워커 스레드 */
    struct kthread_work *current_work;  /* 현재 실행 중인 작업 */
};

struct kthread_work {
    struct list_head    node;
    kthread_work_func_t func;           /* 작업 함수 */
    struct kthread_worker *worker;
};

/* 주요 API */
struct kthread_worker *kthread_create_worker(unsigned int flags,
                                              const char *namefmt, ...);
void kthread_destroy_worker(struct kthread_worker *worker);
bool kthread_queue_work(struct kthread_worker *worker,
                        struct kthread_work *work);
void kthread_flush_work(struct kthread_work *work);
void kthread_flush_worker(struct kthread_worker *worker);

성능 특성 비교

두 메커니즘의 구조적 차이에서 도출되는 정성적 특성 차이는 다음과 같습니다. 절대 수치는 CPU 모델, 워크로드 크기, 스레드 풀 상태, NUMA 배치에 따라 크게 달라지므로 특정 측정값으로 일반화하지 않습니다.

kthread_worker 사용 시나리오

다음 경우에 workqueue 대신 kthread_worker를 사용하는 것이 적합합니다:

• Real-time 우선순위 필요 — 작업이 RT 스케줄링 클래스(Scheduling Class)(SCHED_FIFO/RR)로 실행되어야 할 때
• CPU affinity 고정 — 특정 CPU에 바인딩하여 캐시(Cache) 지역성을 극대화할 때
• 순차 실행 보장 — 작업 간 순서가 중요하고 동시 실행을 허용하지 않을 때
• 단순성 우선 — CMWQ의 복잡한 동시성 관리가 과도할 때 (드라이버 초기화 등)
• 블록킹 작업 — 작업이 오래 블록될 수 있고, 다른 작업에 영향을 주지 않아야 할 때

/* kthread_worker 사용 예시 */
static struct kthread_worker *my_worker;
static struct kthread_work my_work;

static void my_work_func(struct kthread_work *work)
{
    pr_info("work executed on thread: %s\n", current->comm);
    /* 실제 작업 수행 */
}

/* 초기화 */
my_worker = kthread_create_worker(0, "my-worker");
kthread_init_work(&my_work, my_work_func);

/* 작업 큐잉 */
kthread_queue_work(my_worker, &my_work);

/* 정리 */
kthread_flush_worker(my_worker);  /* 대기 중인 작업 모두 완료 대기 */
kthread_destroy_worker(my_worker);

Linux 6.14 이후의 kthread API 정리

Linux 6.14 개발 사이클에서 kthread 서브시스템은 수년간 누적된 중복 API를 정리하고 Per-CPU 스레드 생성 경로를 단일화하는 대규모 리팩터링(Refactoring)을 겪었습니다. 이 섹션은 신규 심볼과 의미 변경을 요약해, 신규 드라이버 작성 시 권장되는 패턴과 이전 심볼의 매핑 관계를 정리합니다.

kthread_run_worker() / kthread_run_worker_on_cpu()

기존에는 워커 스레드를 완전히 가동하려면 kthread_create_worker()로 생성한 뒤 내부 task에 대해 별도로 wake_up_process()를 호출해야 했습니다. Linux 6.14에서 추가된 kthread_run_worker()와 kthread_run_worker_on_cpu()는 "생성 + 기동"을 한 번에 수행하여, 기존 kthread_run()·kthread_run_on_cpu()와 대칭되는 워커 버전 API를 제공합니다.

/* include/linux/kthread.h (Linux 6.14+) */

/* 단일 스레드: 생성 + 자동 기동 */
struct task_struct *kthread_run(int (*fn)(void *), void *data,
                               const char *namefmt, ...);

/* 워커: 생성 + 자동 기동 (6.14 신규) */
struct kthread_worker *kthread_run_worker(unsigned int flags,
                                           const char *namefmt, ...);

/* CPU 바인딩 워커: 생성 + 자동 기동 (6.14 신규) */
/* 정적 인라인 함수이며 가변 인자를 받지 않습니다. */
static inline struct kthread_worker *
kthread_run_worker_on_cpu(int cpu,
                                                  unsigned int flags,
                                                  const char namefmt[]);

/* 구 패턴 (6.13까지) */
struct kthread_worker *w = kthread_create_worker(0, "my-worker");
if (IS_ERR(w))
    return PTR_ERR(w);
wake_up_process(w->task);       /* 별도 기동 필요 */

/* 신 패턴 (6.14+) */
struct kthread_worker *w = kthread_run_worker(0, "my-worker");
if (IS_ERR(w))
    return PTR_ERR(w);
/* 곧바로 kthread_queue_work() 가능 */

kthread_create_on_cpu() / kthread_create_worker_on_cpu() 통합

Linux 6.14 이전에는 Per-CPU 스레드와 Per-CPU 워커 생성 경로가 서로 다른 affinity 초기화 시퀀스를 사용해, 생성 시점과 실제 kthreadd가 포크를 수행하는 시점 사이에 발생하는 hotplug 이벤트에 대한 취약성이 서로 달랐습니다. 6.14의 정리로 두 경로 모두 지연 affinity 적용을 공유합니다. 호출 시점에는 대상 CPU 번호만 기록해 두고, 스레드 컨텍스트가 처음 깨어날 때 kthread::preferred_affinity를 사용해 실제 set_cpus_allowed_ptr()을 호출합니다.

이 변경의 관측 가능한 효과는 다음과 같습니다.

• CPU Hotplug offline 상태의 CPU를 대상으로 kthread_create_on_cpu()를 호출해도 즉시 실패하지 않고, 이후 online 전이 시 정상적으로 바인딩됩니다.
• kthread_bind()와 같이 "강제 바인딩" 의미론이 필요한 경우에는 여전히 명시적으로 호출해야 합니다. preferred_affinity는 선호이지 고정이 아닙니다.
• 생성 함수의 반환값(task_struct *)이 IS_ERR()가 아니라도, CPU 바인딩은 처음 스케줄링되기 전에는 적용되지 않았을 수 있다는 점을 주의해야 합니다.

/* Per-CPU 스레드 생성 — 6.14 이후 권장 흐름 */
for_each_online_cpu(cpu) {
    struct task_struct *t;
    t = kthread_create_on_cpu(per_cpu_fn, data, cpu, "pc-%u");
    if (IS_ERR(t))
        goto err_cleanup;

    /* preferred affinity는 이미 설정됨 — 추가 cpumask 조작 불요 */
    wake_up_process(t);         /* 첫 실행 시 바인딩 실제 적용 */
}

preferred_affinity 의미론

6.14에서 도입된 preferred_affinity 필드는 struct kthread 내부 구조체 중 하나로, 다음 두 경우에 사용됩니다.

1. 지연 Per-CPU 바인딩: kthread_create_on_cpu() 계열 호출에서 대상 CPU를 기록해 두고, 첫 스케줄링 시 적용합니다.
2. Hotplug 재적용: 해당 CPU가 offline되었다가 다시 online될 때, 힌트 마스크를 기준으로 자동 재바인딩을 시도합니다. 기존에는 드라이버가 CPU Hotplug 콜백에서 직접 set_cpus_allowed_ptr()을 호출해야 했습니다.

use_mm → kthread_use_mm 이름 정리

2025년 8월 이후에는 kernel/fork.c를 포함한 여러 소스에서 레거시 심볼 use_mm()/unuse_mm()의 주석과 문서가 kthread_use_mm()/kthread_unuse_mm()로 정리되었습니다. 실제 함수 심볼 자체는 이미 과거에 이름이 변경되었지만, 오래된 주석이 남아 있던 것을 정리하는 작업입니다. 드라이버 측 영향은 없지만, 소스 코드 검색 시 두 이름 모두를 고려해야 합니다.

Linux 6.15 이후의 kthread 관련 변경사항

Linux 6.15는 6.14에서 완성된 kthread 친화성(Affinity) 통합 위에서 추가적인 개선사항을 도입하였습니다. 핵심 kthread API 자체의 대규모 변경보다는 kthread를 활용하는 서브시스템 수준의 개선과 스케줄러 통합에 집중되어 있습니다.

sched_ext 이벤트 카운터와 kthread 인식 개선

커널 6.15부터: sched_ext(BPF 기반 스케줄러 확장) 서브시스템에 코어 이벤트 카운터(Core Event Counter)가 구현되어, BPF 스케줄러 프로그램이 커널 스레드를 포함한 모든 태스크(Task)에 대한 enqueue/dequeue/context-switch 이벤트를 집계할 수 있게 되었습니다.

또한 전역 유휴 CPU 마스크가 NUMA 노드별로 분할되어 커널 스레드가 배치될 CPU를 선택할 때 원격 NUMA 노드를 불필요하게 방문하는 빈도가 줄어들었습니다. 이는 kswapd, kcompactd 등 NUMA 인식이 중요한 커널 스레드의 성능 향상에 기여합니다.

/* sched_ext BPF kfunc: NUMA 노드 수 조회 */
/* 전통적 bpf_xxx 헬퍼가 아니라 kfunc(Kernel Function) 분류입니다. */
int nr_nodes = scx_bpf_nr_node_ids();
/* nr_nodes를 기반으로 per-node idle 마스크 순회 가능 */

CONFIG_SCHED_DEBUG 무조건 활성화와 kthread 관측성

커널 6.15부터: 기존에 CONFIG_SCHED_DEBUG=y를 설정해야 컴파일되던 스케줄러 디버그 인터페이스가 모든 빌드에서 기본 제공됩니다. 이 저장소가 현재 다루는 커널(master)에서는 kernel/sched/debug.c 안에 CONFIG_SCHED_DEBUG 조건부 컴파일이 남아 있지 않으며, 해당 파일은 debugfs_create_dir("sched", NULL) 아래 파일들을 그대로 등록합니다.

이로 인해 커널 스레드 모니터링에 다음 인터페이스를 별도 커널 옵션 없이 사용할 수 있습니다.

# 커널 스레드별 스케줄링 통계 — pid는 pgrep/ps로 직접 확인
cat /proc/$(pgrep kswapd0)/sched

# 런큐(Runqueue)별 실행 가능 태스크 목록 (커널 스레드 포함)
cat /sys/kernel/debug/sched/debug | grep -E 'kswapd|kworker|ksoftirqd'

Lazy Preemption과 커널 스레드 상호작용

Lazy Preemption은 CONFIG_PREEMPT_LAZY=y로 켜는 선점 모델입니다. 아키텍처가 지원 여부를 HAVE_TIF_NEED_RESCHED_LAZY 심볼로 알리며, x86은 이를 정의합니다.

Lazy Preemption은 CFS 태스크의 선점 요청을 틱 경계까지 지연시키지만, 커널 스레드가 SCHED_FIFO 또는 SCHED_RR 정책으로 동작하는 경우에는 즉각 선점이 적용됩니다. 일반 커널 스레드(SCHED_NORMAL)는 Lazy Preemption의 영향을 받아 짧은 연산 후 불필요하게 선점되는 빈도가 줄어들어 캐시 효율성이 향상될 수 있습니다.

현재 메인라인의 kthread API

6.15 이후 kthread 서브시스템은 API를 크게 뒤엎기보다 정밀화하는 방향으로 발전했습니다. 이 절은 현재 메인라인 커널의 include/linux/kthread.h와 kernel/kthread.c에 실제로 존재하는 심볼과 동작을 기준으로 정리합니다.

지연 affinity 재작업의 최종 형태

6.14에서 시작된 Per-CPU kthread affinity 통합은 이후 struct kthread에 affinity_node(전역 연결 리스트 노드)와 preferred_affinity(CPU 마스크) 두 필드를 추가하며 완성되었습니다. 현재 동작은 다음과 같습니다.

/* kernel/kthread.c — 선호 affinity를 힌트로 등록 */
int kthread_affine_preferred(struct task_struct *p,
                              const cpumask *mask)
{
    struct kthread *kthread = to_kthread(p);

    WARN_ON_ONCE(kthread->preferred_affinity);
    kthread->preferred_affinity = kzalloc_obj(struct cpumask);
    if (!kthread->preferred_affinity)
        return -ENOMEM;

    cpumask_copy(kthread->preferred_affinity, mask);

    /* 전역 리스트에 연결해 CPU offline/online을 추적 */
    mutex_lock(&kthread_affinity_lock);
    list_add_tail(&kthread->affinity_node, &kthread_affinity_list);
    mutex_unlock(&kthread_affinity_lock);

    /* 필요 시 즉시 적용 */
    if (force || k->preferred_affinity || k->node != NUMA_NO_NODE) {
        struct cpumask *cpus = kthread->preferred_affinity;
        ...
    }
    return 0;
}

housekeeping 스레드 재구성

kthreads_update_housekeeping()이 CPU 온라인/오프라인 시점에 housekeeping 성격의 per-CPU 스레드(kworker 계열, khugepaged, kcompactd 등)를 일괄 재구성합니다. kthread.c는 이 함수에서 affinity_node 리스트를 순회하며 오프라인 CPU에 묶인 스레드를 정리하고 마이그레이션 대상이 되는 스레드를 재배치(Relocation)합니다.

# per-CPU housekeeping 스레드와 CPU 바인딩 상태 확인
for t in /sys/devices/system/cpu/cpu*/thread_siblings/*/topology/thread_siblings_list; do
  echo "$t"; cat "$t"
done

# 커널 스레드별 실제 CPU 목록
taskset -pc $(pgrep -f 'kworker/0')

안전성 개선 API

커널 스레드 이름 잘림

task_struct.comm는 TASK_COMM_LEN(16바이트, NUL 포함)으로 제한되기 때문에 numactl-kernel-hugepages 같은 긴 이름은 잘립니다. 현재 커널은 이를 위해 struct kthread::full_name에 전체 이름을 따로 보관하고, get_kthread_comm()가 이를 우선 반환합니다.

# ps는 잘린 이름을 보여줍니다
ps -eo pid,comm | grep -E '^\s*[0-9]+ numactl'

# 전체 이름은 dmesg 로그에서 확인
dmesg | grep -i 'numactl-kernel-hugepages'

주요 커널 스레드 종합

부팅 직후 ps -eo pid,ppid,cls,ni,comm | head -30을 실행하면 다양한 커널 스레드를 확인할 수 있습니다. 주요 커널 스레드의 역할을 정리합니다:

주요 커널 스레드 실전 분석

리눅스 커널의 주요 커널 스레드들이 실제로 어떻게 구현되어 있는지 소스 코드 수준에서 분석합니다. 각 스레드의 메인 루프 구조, 슬립/웨이크업 메커니즘, 그리고 시스템에서의 역할을 살펴봅니다.

kswapd — 페이지 회수 데몬

kswapd는 메모리가 부족해지면 비활성 페이지를 회수하는 커널 스레드입니다. NUMA 노드당 1개씩 생성되며(kswapd0, kswapd1, ...), 워터마크(Watermark) 기반으로 동작합니다.

/* mm/vmscan.c - kswapd() 핵심 루프 (간략화) */
static int kswapd(void *p)
{
    unsigned int alloc_order, reclaim_order;
    pg_data_t *pgdat = (pg_data_t *)p;

    set_freezable();

    for (;;) {
        alloc_order = reclaim_order = 0;

        /* 1. 워터마크 충족 시 슬립 */
        prepare_to_wait(&pgdat->kswapd_wait,
                        &wait, TASK_INTERRUPTIBLE);
        if (kswapd_is_satisfied(pgdat))
            schedule();
        finish_wait(&pgdat->kswapd_wait, &wait);

        /* 2. freezer 확인 */
        if (try_to_freeze() || kthread_should_stop())
            break;

        /* 3. 페이지 회수 실행 */
        reclaim_order = balance_pgdat(pgdat, alloc_order,
                                      highest_zoneidx);
    }
    return 0;
}
/* wake_up_interruptible(&pgdat->kswapd_wait) → 메모리 부족 시 깨움 */

동작 흐름:

• 워터마크 기반 회수: 각 존(Zone)은 pages_min < pages_low < pages_high 세 단계의 워터마크를 가집니다. 가용 페이지가 pages_low 이하로 떨어지면 kswapd가 깨어나고, pages_high까지 회수한 후 다시 슬립합니다.
• 깨움 경로: alloc_page() → __alloc_pages_slowpath() → wakeup_kswapd() 순서로 메모리 할당 실패 시 kswapd를 깨웁니다.
• 회수 경로: balance_pgdat() → shrink_node() → shrink_lruvec() 순서로 LRU 리스트에서 비활성 페이지를 회수합니다.
• NUMA 인식: 각 NUMA 노드마다 별도의 kswapd가 실행되어 해당 노드의 메모리만 관리합니다.

jbd2 — ext4 저널 커밋 스레드

jbd2(Journaling Block Device 2)는 ext4 파일시스템(Filesystem)의 저널 커밋을 담당합니다. 블록 디바이스별 1개씩 생성되며(jbd2/sda1-8 등), 트랜잭션의 원자적(Atomic) 커밋을 보장합니다.

/* fs/jbd2/journal.c - kjournald2() 핵심 루프 (간략화) */
static int kjournald2(void *arg)
{
    journal_t *journal = arg;

    set_freezable();

    while (!kthread_should_stop()) {
        if (journal->j_flags & JBD2_UNMOUNT)
            break;

        /* 트랜잭션 커밋 주기 (기본 5초) */
        if (journal->j_commit_interval) {
            wait_event_interruptible_timeout(
                journal->j_wait_commit,
                journal_needs_commit(journal) ||
                kthread_should_stop(),
                journal->j_commit_interval);
        }

        if (journal_needs_commit(journal))
            jbd2_journal_commit_transaction(journal);

        if (freezing(current))
            try_to_freeze();
    }
    return 0;
}

주요 특징:

• 주기적 커밋: 기본 5초(j_commit_interval) 간격으로 대기 중인 트랜잭션을 디스크에 커밋합니다.
• 즉시 커밋: fsync() 호출 시 j_wait_commit 대기 큐(Wait Queue)를 깨워 즉시 커밋을 트리거합니다.
• 트랜잭션 배리어(Barrier): 저널 커밋 시 디스크 쓰기 배리어를 사용하여 데이터 무결성(Integrity)을 보장합니다. 전원 장애 시에도 파일시스템 일관성이 유지됩니다.
• 언마운트 처리: JBD2_UNMOUNT 플래그가 설정되면 남은 트랜잭션을 모두 커밋하고 종료합니다.

migration — CPU 간 태스크 이동

migration 스레드는 CPU 간 태스크 이동을 수행하는 핵심 커널 스레드입니다. SCHED_FIFO 우선순위 99로 실행되며, 시스템에서 가장 높은 RT 우선순위를 가집니다.

/* kernel/sched/core.c - migration 스레드 핵심 */
/* SCHED_FIFO, 우선순위 99 — 시스템에서 가장 높은 RT 우선순위 */
/* stop_machine()의 구현 기반 */

/* 마이그레이션이 필요한 경우:
 * 1. set_cpus_allowed_ptr() - 태스크 affinity 변경
 * 2. load_balance() - CFS 로드 밸런싱
 * 3. CPU offline - 해당 CPU의 모든 태스크 이동
 */
static int migration_thread(void *data)
{
    int cpu = (long)data;
    struct rq *rq = cpu_rq(cpu);

    for (;;) {
        struct migration_arg *arg;

        if (kthread_should_park())
            kthread_parkme();

        /* stop_one_cpu() 요청 대기 */
        raw_spin_lock_irq(&rq->lock);
        /* active migration 실행 */
        __migrate_task(arg->task, arg->dest_cpu);
        raw_spin_unlock_irq(&rq->lock);
    }
    return 0;
}

마이그레이션이 발생하는 주요 경우:

• set_cpus_allowed_ptr(): 태스크의 CPU affinity가 변경되어 현재 CPU에서 더 이상 실행할 수 없을 때, migration 스레드가 해당 태스크를 허용된 CPU로 이동시킵니다.
• load_balance(): CFS 스케줄러의 로드 밸런싱 과정에서 과부하된 CPU에서 여유 있는 CPU로 태스크를 이동합니다.
• CPU offline: CPU가 오프라인 상태로 전환될 때, 해당 CPU에서 실행 중인 모든 태스크를 다른 CPU로 강제 이동합니다.

Real-Time 커널 및 스케줄링 클래스

커널 스레드는 기본적으로 CFS(COMPLETELY_FAIR_SCHEDULER)에 의해 스케줄링되지만, 실시간 요구사항이 있는 작업에는 실시간 스케줄링 클래스를 적용할 수 있습니다.

스케줄링 클래스 적용

SCHED_FIFO와 SCHED_RR은 실시간 스케줄링 정책으로, 커널 스레드에 적용하면 우선순위에 따른 선점 스케줄링이 가능합니다:

/* 커널 스레드에 실시간 우선순위 설정 */
struct sched_param param;
param.sched_priority = 50;  /* 1~99, 높은 값이 높은 우선순위 */

/* SCHED_FIFO: 선점 가능하면 즉시 실행, 타임 슬라이스 없음 */
sched_setscheduler(kth, SCHED_FIFO, &param);

/* SCHED_RR: 타임 슬라이스 기반 라운드 로빈 */
sched_setscheduler(kth, SCHED_RR, &param);

/* SCHED_NORMAL로 복원 */
sched_setscheduler(kth, SCHED_NORMAL, NULL);

migration 스레드 (RT 최고 우선순위)

CPU 간 태스크 마이그레이션을 담당하는 migration/N 스레드는 실시간 최고 우선순위(SCHED_FIFO, 우선순위 99)로 실행됩니다:

# migration 스레드의 스케줄링 정보 확인
chrt -p $(pgrep -f "migration/0")
# pid 57의 스케줄링 정책:
# policy: SCHED_FIFO priority: 99

cgroup과 커널 스레드

커널 스레드는 기본적으로 모든 cgroup에 속하지 않지만, 특정 조건에서 cgroup 제어를 받을 수 있습니다.

커널 스레드의 cgroup 규칙

/* 커널 스레드를 특정 cgroup에 추가 (cgoup v2 threaded 모드) */
/* 주의: 모든 커널 스레드가 이 기능을 지원하는 것은 아님 */
int kthread_attach_group(struct task_struct *kth, struct cgroup *cgrp)
{
    int ret;

    get_task_struct(kth);
    cgroup_attach_task(cgrp, kth, false);
    put_task_struct(kth);
    return ret;
}

NUMA 인식 커널 스레드 (NUMA-Aware Kernel Threads)

NUMA(Non-Uniform Memory Access) 아키텍처에서 커널 스레드의 메모리 지역성(Locality)은 성능에 큰 영향을 미칩니다. kthread_create_on_node()를 사용하면 특정 NUMA 노드에 task_struct와 커널 스택을 할당하여 메모리 접근 지연을 최소화할 수 있습니다.

/* NUMA 인식 커널 스레드 생성 */
struct task_struct *kthread_create_on_node(
    int (*threadfn)(void *data),
    void *data, int node,
    const char namefmt[], ...)

/* 예시: 특정 NUMA 노드에 스레드 생성 */
for_each_online_node(nid) {
    struct task_struct *t;
    t = kthread_create_on_node(my_fn, node_data[nid],
                               nid, "mythread/%d", nid);
    kthread_bind_mask(t, cpumask_of_node(nid));
    wake_up_process(t);
}

NUMA 노드별 커널 스레드 대표 예시 — kswapd:

/* kswapd의 NUMA 노드별 생성 (mm/vmscan.c) */
int kswapd_run(int nid)
{
    pg_data_t *pgdat = NODE_DATA(nid);
    pgdat->kswapd = kthread_create_on_node(kswapd,
        pgdat, nid, "kswapd%d", nid);
    set_cpus_allowed_ptr(pgdat->kswapd,
        cpumask_of_node(nid));
    wake_up_process(pgdat->kswapd);
    return 0;
}

NUMA 인식 커널 스레드의 핵심 특징:

• kthread_create_on_node(): node 매개변수로 NUMA 노드를 지정하면, task_struct와 커널 스택이 해당 노드의 로컬 메모리에 할당됩니다.
• kthread_bind_mask(): 스레드의 CPU affinity를 해당 NUMA 노드의 CPU들로 제한하여, 항상 로컬 메모리에 접근하도록 보장합니다.
• kswapd: 노드별 1개로 생성되어 자동으로 NUMA를 인식합니다. 각 kswapd는 자신의 노드 메모리만 관리합니다.
• kcompactd: 메모리 컴팩션 데몬으로, kswapd와 마찬가지로 노드별 1개씩 생성됩니다.

BH Workqueue

최근 커널에서는 tasklet 대체를 위해 BH (Bottom-Half) Workqueue가 도입되었습니다. WQ_BH 플래그를 준 workqueue는 워커 스레드가 아니라 큐잉한 CPU의 softirq 컨텍스트에서 작업을 실행합니다. 전용 커널 스레드를 새로 만들지 않고, tasklet이 제공하던 softirq 실행 지점을 workqueue의 flush/cancel 메커니즘과 결합한 형태입니다.

BH Workqueue vs Tasklet

/* BH Workqueue 사용 예시 */
#include <linux/workqueue.h>

static void bh_work_handler(struct work_struct *work)
{
    pr_info("BH work executed in softirq context\n");
    /* 실제 작업 — atomic 컨텍스트에서 실행됨 */
}

static void bh_work_handler_highpri(struct work_struct *work)
{
    pr_info("High priority BH work\n");
}

/* 시스템 제공 BH workqueue 사용 */
static struct work_struct my_bh_work;
static struct work_struct highpri_work;

static int __init bh_init(void)
{
    INIT_WORK(&my_bh_work, bh_work_handler);
    queue_work(system_bh_wq, &my_bh_work);

    /* 고우선순위 BH workqueue */
    INIT_WORK(&highpri_work, bh_work_handler_highpri);
    queue_work(system_bh_highpri_wq, &highpri_work);

    return 0;
}

커스텀 BH Workqueue 생성

/* 커스텀 BH workqueue 생성 */
/* WQ_BH는 WQ_HIGHPRI / WQ_PERCPU와만 조합할 수 있습니다. */
struct workqueue_struct *my_bh_wq;
struct workqueue_struct *my_bh_pc_wq;

my_bh_wq = alloc_workqueue("my-bh-wq",
                         WQ_BH,          /* BH 플래그 필수 */
                         0);  /* max_active: 0이면 기본값 */

/* per-CPU BH workqueue가 필요한 경우 */
my_bh_pc_wq = alloc_workqueue("my-bh-pcwq",
                            WQ_BH | WQ_PERCPU | WQ_HIGHPRI,
                            1);  /* CPU당 동시 실행 1개 */

/* 사용 후 파괴 */
destroy_workqueue(my_bh_wq);

성능 튜닝 및 모니터링

커널 스레드 성능 튜닝

대용량 시스템에서는 커널 스레드의 동작을 튜닝하여 성능을 최적화할 수 있습니다:

/* CPU affinity 설정 — 특정 CPU에서만 실행되도록 제한 */
cpumask_t mask;
cpumask_clear(&mask);
cpumask_set_cpu(0, &mask);  /* CPU 0에만 바인딩 */
set_cpus_allowed_ptr(current, &mask);

/*nice 값 설정 — 스케줄링 우선순위 조절 */
set_user_nice(current, -10);  /* 더 높은 우선순위 */

/* 커널 스레드 시작 지연 — 시스템 부하 상태 확인 후 */
if (system_state == SYSTEM_RUNNING)
    kth = kthread_run(fn, data, "delayed-kthread");
else
    schedule_delayed_work(&delayed_init, msecs_to_jiffies(5000));

커널 스레드 통계 확인

# 커널 스레드별 CPU 사용량 확인
ps -eo pid,ppid,comm,%cpu,%mem,psr | grep -E "\\[" | sort -k4 -rn | head -20

# 특정 커널 스레드의 상세 통계
cat /proc/<pid>/sched
# se.exec_start        :     123456789.123456
# se.vruntime         :          1234.567890
# se.sum_exec_runtime :          5678.901234
# se.nr_switches      :             12345
# se.nr_voluntary_switches:      12000
# se.nr_involuntary_switches:      345
# se.wait_start       :          0.000000
# se.sleep_start      :     123456789.123456
# se.sleep_max        :       1234.567890
# se.iowait_sum       :        123.456789
# se.iowait_max      :         12.345678
# se.nr_migrations    :           1234

# kworker 스레드별 CPU 사용량 상세
cat /proc/interrupts | head -5
cat /proc/softirqs

# workqueue 통계 (Linux 4.11+)
cat /sys/kernel/debug/workqueue

perf 도구 활용

# 특정 커널 스레드 프로파일링
perf record -p <pid> -g -- sleep 10
perf report

# 커널 스레드 생성/종료 이벤트 추적
perf record -e sched:sched_kthread_stop -e sched:sched_kthread_start -a -- sleep 30
perf script

# workqueue 작업 실행 추적
perf record -e workqueue:workqueue_execute_start -e workqueue:workqueue_execute_end -a
perf report

커널 스레드 디버깅(Debugging)

커널 스레드가 응답하지 않거나 예상대로 동작하지 않을 때 사용할 수 있는 디버깅 기법들입니다:

Hung Task 탐지

# Hung task 감지 활성화 (기본 120초)
echo 120 > /proc/sys/kernel/hung_task_timeout_secs
echo 1 > /proc/sys/kernel/hung_task_warnings

# D 상태(UNINTERRUPTIBLE)에 장시간 머무는 스레드 확인
ps -eo pid,stat,wchan:30,comm | grep -E '^[[:space:]]*[0-9]+[[:space:]]+D'

# 특정 스레드의 대기 이유 확인
cat /proc/<pid>/stack
# [<0>] __schedule+0x2e0/0x970
# [<0>] schedule+0x46/0xb0
# [<0>] io_schedule+0x16/0x40
# [<0>] wait_on_page_bit+0x15e/0x250
# → 페이지 I/O 대기 중

ftrace로 스레드 추적

# 특정 커널 스레드의 함수 호출 추적
cd /sys/kernel/debug/tracing
echo 0 > tracing_on
echo function_graph > current_tracer
echo 1 > options/funcgraph-proc
echo kswapd0 > set_ftrace_pid  # 또는 PID 번호
echo 1 > tracing_on
sleep 5
echo 0 > tracing_on
cat trace | head -100

# kthread 생성/종료 이벤트 추적
echo 1 > events/sched/sched_process_fork/enable
echo 1 > events/sched/sched_process_exit/enable
echo 1 > tracing_on
cat trace_pipe

데드락 탐지

# lockdep으로 락 의존성 문제 감지 (CONFIG_PROVE_LOCKING 필요)
dmesg | grep -i "possible circular locking"

# 모든 스레드의 락 정보 확인
cat /proc/lock_stat

# 특정 스레드가 대기 중인 락 확인
cat /proc/<pid>/wchan  # 대기 중인 커널 함수

# SysRq로 전체 스레드 스택 덤프 (긴급 상황)
echo t > /proc/sysrq-trigger
dmesg | tail -200

디버깅 팁

커널 스레드 시각화

커널 스레드 상태 시각화

# 모든 커널 스레드의 상태 시각화 (심플)
for pid in $(ls /proc/ | grep -E '^[0-9]+$'); do
    if grep -q '\[.*\]' /proc/$pid/comm 2>/dev/null; then
        state=$(awk '{print $3}' /proc/$pid/stat)
        comm=$(cat /proc/$pid/comm)
        printf "%-30s %-5s %s\n" "$comm" "$pid" "$state"
    done

# kernel thread 상태 그래프 (Python 스크립트 예시)
#!/usr/bin/env python3
import os

threads = []
for pid in os.listdir('/proc'):
    if not pid.isdigit(): continue
    try:
        with open(f'/proc/{pid}/comm') as f:
            comm = f.read().strip()
            if comm.startswith('[') and comm.endswith(']'):
                with open(f'/proc/{pid}/stat') as s:
                    state = s.read().split()[2]
                    threads.append((comm, pid, state))
    except: pass

# 상태별 분류
states = {}
for t in threads:
    states.setdefault(t[2], []).append(t)

for state, lst in sorted(states.items()):
    print(f"# {state}: {len(lst)} threads")
    for comm, pid, _ in lst[:5]:
        print(f"  {comm} (pid={pid})")

Flame Graph로 커널 스레드 분석

# 커널 스레드 스택 flamegraph 생성
perf record -F 99 -a -g -- sleep 30
perf script | ./stackcollapse-perf.pl | ./flamegraph.pl > kthread.svg
# 특정 커널 스레드만 프로파일링
perf record -F 99 -p $(pgrep -f kworker/0:1) -g -- sleep 10
perf script | ./stackcollapse-perf.pl | ./flamegraph.pl > kworker0.svg

내부 구현 상세

to_kthread() / struct kthread

각 커널 스레드에는 struct kthread가 부속되며, task_struct.worker_private 포인터를 통해 접근합니다:

/* kernel/kthread.c (최신 커널 기준) */
struct kthread {
    unsigned long            flags;          /* KTHREAD_SHOULD_STOP 등 */
    unsigned int             cpu;            /* per-CPU kthread의 대상 CPU */
    unsigned int             node;           /* NUMA 노드 할당 정보 */
    int                      started;        /* 첫 wake-up 후 시작 여부 */
    int                      result;         /* 스레드 함수 반환값 */
    int                      (*threadfn)(void *);
    void                     *data;
    struct completion       parked;         /* park/unpark 동기화 */
    struct completion       exited;         /* stop/exit 동기화 */
#ifdef CONFIG_BLK_CGROUP
    struct cgroup_subsys_state *blkcg_css;  /* blkcg 연동 */
#endif
    char                     *full_name;    /* truncation-safe 전체 이름 */
    struct task_struct      *task;         /* 역참조 백포인터 */
    struct list_head        affinity_node;  /* affinity_list 연결용 */
    struct cpumask          *preferred_affinity; /* 지연 어피니티 적용용 */
};

/* 플래그 비트 — IS_PARKED는 없음! */
enum KTHREAD_BITS {
    KTHREAD_IS_PER_CPU   = 0,   /* per-CPU 스레드 여부 */
    KTHREAD_SHOULD_STOP  = 1,   /* kthread_stop() 요청됨 */
    KTHREAD_SHOULD_PARK  = 2,   /* kthread_park() 요청됨 */
    /* KTHREAD_IS_PARKED는 존재하지 않음 — park 상태는 completion으로 추적 */
};

/* task_struct에서 kthread 구조체 접근 */
static inline struct kthread *to_kthread(struct task_struct *k)
{
    WARN_ON(!(k->flags & PF_KTHREAD));
    return k->worker_private;
}

/* 헤더에서 내부 연결 확인 (lock-free) */
static inline struct kthread *tsk_is_kthread(struct task_struct *p)
{
    if (p->flags & PF_KTHREAD)
        return p->worker_private;
    return NULL;
}

kernel_thread() → kernel_clone()

kernel_thread()는 kernel_clone()의 래퍼로, 커널 모드에서 새 태스크를 생성합니다:

/* kernel/fork.c */
pid_t kernel_thread(int (*fn)(void *), void *arg,
                     const char *name, unsigned long flags)
{
    struct kernel_clone_args args = {
        .flags       = ((lower_32_bits(flags) | CLONE_VM | CLONE_UNTRACED)
                        & ~CSIGNAL),
        .exit_signal = (lower_32_bits(flags) & CSIGNAL),
        .fn          = fn,
        .fn_arg      = arg,
        .name        = name,
        .kthread     = 1,   /* PF_KTHREAD 설정 */
    };
    return kernel_clone(&args);
}

/* kernel_clone()은 copy_process()를 호출하여:
 * 1. task_struct 할당
 * 2. PF_KTHREAD 플래그 설정
 * 3. mm = NULL (유저 주소 공간 없음)
 * 4. 커널 스택 할당
 * 5. 스케줄러에 등록
 */

동기화 및 슬립 패턴

completion 기반 패턴

커널 스레드의 시작/종료를 동기화할 때 completion을 사용합니다:

static DECLARE_COMPLETION(thread_started);

static int my_thread_fn(void *data)
{
    /* 초기화 완료 시그널 */
    complete(&thread_started);

    while (!kthread_should_stop()) {
        do_work();
        msleep(100);
    }
    return 0;
}

/* 생성 측 */
kth = kthread_run(my_thread_fn, data, "my-thread");
wait_for_completion(&thread_started);
/* 이 시점에서 스레드 초기화가 확실히 완료됨 */

Freezable 커널 스레드

시스템 절전(suspend) 시 커널 스레드도 얼릴 수 있습니다. I/O를 수행하는 커널 스레드는 suspend 전에 정지해야 데이터 손상을 방지할 수 있습니다:

static int freezable_thread_fn(void *data)
{
    /* 이 스레드는 freezable — suspend 시 동결됨 */
    set_freezable();

    while (!kthread_should_stop()) {
        /* try_to_freeze()가 suspend 시 스레드를 정지시킴 */
        try_to_freeze();

        do_io_work();

        /* freezable 슬립 — suspend 도중에 깨어나지 않음 */
        wait_event_freezable(my_wq, has_work || kthread_should_stop());
    }
    return 0;
}

/* wait_event_freezable은 내부적으로:
 * 1. freezing(current)이면 try_to_freeze() 호출
 * 2. 조건 확인
 * 3. 슬립
 * 을 안전하게 조합합니다 */

디버깅

커널 스레드 식별하기

# 모든 커널 스레드 나열 (대괄호 표기)
ps -eo pid,ppid,cls,ni,psr,comm | awk '$2==2 || $1==2'

# 특정 커널 스레드의 상세 정보
cat /proc/<pid>/status
# Name:   kswapd0
# State:  S (sleeping)
# Tgid:   <pid>
# VmSize: (없음 — 커널 스레드는 유저 메모리 없음)

# 커널 스레드의 CPU affinity 확인
taskset -p <pid>

# 커널 스레드 스택 트레이스
cat /proc/<pid>/stack

디버깅 도구

# ftrace로 kthread 생성 추적
echo 1 > /sys/kernel/debug/tracing/events/sched/sched_kthread_work_execute_start/enable
echo 1 > /sys/kernel/debug/tracing/events/sched/sched_kthread_work_queue_work/enable
cat /sys/kernel/debug/tracing/trace

# SysRq-T: 모든 태스크의 스택 덤프 (커널 스레드 포함)
echo t > /proc/sysrq-trigger
dmesg | less

# 특정 커널 스레드의 스케줄링 통계
cat /proc/<pid>/sched

# perf로 커널 스레드 프로파일링
perf top -t <pid>

코드 예제 (Code Examples)

기본 커널 스레드 모듈

#include <linux/module.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/sched.h>

static struct task_struct *my_thread;

static int thread_func(void *data)
{
    int count = 0;

    pr_info("kthread started: pid=%d, comm=%s\n",
            current->pid, current->comm);

    while (!kthread_should_stop()) {
        pr_info("kthread iteration %d (cpu=%d)\n",
                count++, smp_processor_id());

        msleep(2000);
    }

    pr_info("kthread stopping, count=%d\n", count);
    return count;
}

static int __init my_init(void)
{
    pr_info("creating kernel thread\n");

    my_thread = kthread_run(thread_func, NULL, "example_kthread");
    if (IS_ERR(my_thread)) {
        pr_err("kthread_run failed: %ld\n", PTR_ERR(my_thread));
        return PTR_ERR(my_thread);
    }

    pr_info("kthread created: pid=%d\n", my_thread->pid);
    return 0;
}

static void __exit my_exit(void)
{
    int ret;

    if (my_thread) {
        ret = kthread_stop(my_thread);
        pr_info("kthread stopped, return value: %d\n", ret);
    }
}

module_init(my_init);
module_exit(my_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Basic Kernel Thread Example");

Per-CPU 커널 스레드

#include <linux/module.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/cpumask.h>

static struct task_struct * __percpu *per_cpu_threads;

static int per_cpu_fn(void *data)
{
    unsigned int cpu = (unsigned long)data;

    pr_info("per-cpu kthread on CPU %u started (pid=%d)\n",
            cpu, current->pid);

    while (!kthread_should_stop()) {
        if (kthread_should_park())
            kthread_parkme();

        pr_info("CPU %u: doing work\n", cpu);
        msleep(5000);
    }
    return 0;
}

static int __init percpu_init(void)
{
    unsigned int cpu;

    per_cpu_threads = alloc_percpu(struct task_struct *);
    if (!per_cpu_threads)
        return -ENOMEM;

    for_each_online_cpu(cpu) {
        struct task_struct *t;
        t = kthread_create_on_cpu(per_cpu_fn,
                (void *)(unsigned long)cpu,
                cpu, "my_pcpu/%u");
        if (IS_ERR(t)) {
            pr_err("failed on CPU %u\n", cpu);
            continue;
        }
        *per_cpu_ptr(per_cpu_threads, cpu) = t;
        wake_up_process(t);
    }
    return 0;
}

static void __exit percpu_exit(void)
{
    unsigned int cpu;

    for_each_online_cpu(cpu) {
        struct task_struct *t = *per_cpu_ptr(per_cpu_threads, cpu);
        if (t)
            kthread_stop(t);
    }
    free_percpu(per_cpu_threads);
}

module_init(percpu_init);
module_exit(percpu_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Per-CPU Kernel Thread Example");

kthread_worker 사용 예제

#include <linux/module.h>
#include <linux/kthread.h>

static struct kthread_worker *worker;
static struct kthread_work my_work;
static struct kthread_delayed_work my_delayed_work;

static void work_func(struct kthread_work *work)
{
    pr_info("work executed: thread=%s, cpu=%d\n",
            current->comm, smp_processor_id());
}

static void delayed_work_func(struct kthread_work *work)
{
    pr_info("delayed work executed\n");

    /* 자기 자신을 다시 큐잉 (주기적 실행) */
    kthread_queue_delayed_work(worker, &my_delayed_work,
                               msecs_to_jiffies(3000));
}

static int __init worker_init(void)
{
    /* 워커 생성 (전용 스레드 자동 생성) */
    worker = kthread_create_worker(0, "my_kworker");
    if (IS_ERR(worker))
        return PTR_ERR(worker);

    /* 즉시 실행 작업 */
    kthread_init_work(&my_work, work_func);
    kthread_queue_work(worker, &my_work);

    /* 지연 실행 작업 (3초 후) */
    kthread_init_delayed_work(&my_delayed_work, delayed_work_func);
    kthread_queue_delayed_work(worker, &my_delayed_work,
                               msecs_to_jiffies(3000));

    return 0;
}

static void __exit worker_exit(void)
{
    kthread_cancel_delayed_work_sync(&my_delayed_work);
    kthread_destroy_worker(worker);
}

module_init(worker_init);
module_exit(worker_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("kthread_worker Example");

Freezable 커널 스레드

#include <linux/module.h>
#include <linux/kthread.h>
#include <linux/freezer.h>
#include <linux/wait.h>

static struct task_struct *freeze_thread;
static DECLARE_WAIT_QUEUE_HEAD(wq);
static bool do_work = false;

static int freezable_fn(void *data)
{
    set_freezable();

    while (!kthread_should_stop()) {
        /* suspend 시 자동 동결, resume 시 자동 해동 */
        wait_event_freezable(wq,
            do_work || kthread_should_stop());

        if (kthread_should_stop())
            break;

        do_work = false;
        pr_info("freezable thread: doing I/O work\n");
    }
    return 0;
}

static int __init freeze_init(void)
{
    freeze_thread = kthread_run(freezable_fn, NULL, "freezable_kth");
    return IS_ERR(freeze_thread) ? PTR_ERR(freeze_thread) : 0;
}

static void __exit freeze_exit(void)
{
    kthread_stop(freeze_thread);
}

module_init(freeze_init);
module_exit(freeze_exit);
MODULE_LICENSE("GPL");

모듈 빌드 및 테스트 방법

위 예제들을 실제로 빌드하고 커널에 로드하여 동작을 확인하는 단계별 절차입니다:

1단계: Makefile 작성

# Makefile
obj-m := example_kthread.o

KDIR ?= /lib/modules/$(shell uname -r)/build
PWD  := $(shell pwd)

all:
	$(MAKE) -C $(KDIR) M=$(PWD) modules

clean:
	$(MAKE) -C $(KDIR) M=$(PWD) clean

2단계: 빌드

# 커널 헤더 패키지가 필요합니다 (Ubuntu: linux-headers-$(uname -r))
sudo apt install linux-headers-$(uname -r)   # Ubuntu/Debian
# sudo dnf install kernel-devel             # Fedora/RHEL

make

3단계: 로드 및 모니터링

# 터미널 1: 커널 로그 실시간 모니터링
dmesg -w

# 터미널 2: 모듈 로드
sudo insmod example_kthread.ko

# 커널 스레드 확인 (대괄호 표기)
ps aux | grep '\[example'

# /proc을 통한 스레드 정보 확인
cat /proc/$(pgrep example_kthread)/status

# 스택 추적 (CONFIG_STACKTRACE 필요)
cat /proc/$(pgrep example_kthread)/stack

4단계: 언로드 및 정리

# 모듈 언로드 (module_exit → kthread_stop 호출)
sudo rmmod example_kthread

# 로드된 모듈 목록 확인
lsmod | grep example

# 커널 로그에서 스레드 종료 메시지 확인
dmesg | tail -10

커널 스레드 스택 제약 (Kernel Thread Stack Constraints)

커널 스레드는 제한된 크기의 스택에서 실행됩니다. 유저 공간 스레드(pthread)가 기본 8MB 스택을 갖는 것과 달리, 커널 스레드 스택은 아키텍처별로 훨씬 작습니다:

/* THREAD_SIZE는 아키텍처마다 아래 형태로 정의됩니다 (x86_64, 4K 페이지) */
/* ORDER는 지수(exponent)입니다. 2를 PAGE_SIZE만큼 왼쪽으로 시프트 = 4페이지 */
#define THREAD_SIZE_ORDER    (2)              /* 2 << 12bit = 4페이지 */
#define THREAD_SIZE          (PAGE_SIZE << THREAD_SIZE_ORDER)  /* 4096 << 2 = 16384 = 16 KiB */

CONFIG_VMAP_STACK — 가상 매핑 스택

Linux 4.9부터 CONFIG_VMAP_STACK=y(기본값)로 커널 스택이 가상 주소 공간에 매핑됩니다. 이 설정의 핵심 이점은 스택 오버플로(Stack Overflow) 감지입니다:

• 가드 페이지(Guard Page): 스택의 끝에 접근 불가한 페이지를 배치합니다. 스택이 범위를 넘으면 페이지 폴트(Page Fault)가 발생하여 즉시 커널 패닉을 유발합니다. 이 덕분에 스택 오버플로가 다른 데이터를 조용히 덮어쓰는 것을 방지합니다.
• 물리 메모리(Physical Memory) 인접 불필요: 가상 매핑이므로 스택 페이지들이 물리 메모리에서 연속적일 필요가 없습니다.
• 주의: VMAP_STACK은 NMI(Non-Maskable Interrupt)와 double-fault 처리를 위한 별도의 스택(Interrupt Stack Table)을 사용하는 x86_64에서도 호환됩니다.

# 커널 설정 확인
grep CONFIG_VMAP_STACK /boot/config-$(uname -r)
# CONFIG_VMAP_STACK=y  ← 기본 활성화

# 커널 스택 사용량 상한 (x86)
cat /proc/sys/kernel/stackdetector   # 기능 지원 여부
cat /proc/$(pgrep kworker/0)/stack | head   # 태스크별 현재 스택 프레임

스택 관련 흔한 실수

커널 스레드 함수에서 스택을 많이 사용하는 패턴은 위험합니다:

/* 위험: 커널 스택에 큰 로컬 배열 */
static int bad_thread_fn(void *data)
{
    char buf[8192];      /* x86_64 16K 스택의 절반! */
    struct big_struct s; /* 큰 구조체도 위험 */
    ...
}

/* 올바른 방법: 힙(Heap) 할당 사용 */
static int good_thread_fn(void *data)
{
    char *buf = kmalloc(8192, GFP_KERNEL);
    if (!buf)
        return -ENOMEM;

    /* 작업 수행 */

    kfree(buf);
    return 0;
}

/* 또는 vmalloc()으로 큰 버퍼 할당 */
char *buf = vmalloc(64 * 1024);  /* 64KB — kmalloc 한계 초과 시 */

호출 깊이 제약

커널 함수 호출 체인이 깊어지면 스택이 누적됩니다. 특히 재귀(Recursion) 호출은 커널에서 매우 위험합니다:

• 커널 함수의 스택 프레임(Stack Frame)은 보통 수십~수백 바이트 규모입니다.
• 재귀 호출 깊이가 스택 크기에 근접하면 16 KiB 스택을 소진할 수 있습니다. 재귀 깊이에 상한을 두거나, 아예 반복문으로 바꿉니다.
• 인터럽트 진입이 현재 스레드의 스택을 공유하므로(아키텍처에 따라 다름), 하드웨어 예외 핸들러와 인터럽트 스택 프레임이 추가 깊이를 소비합니다. x86_64는 IST(Interrupt Stack Table)로 NMI·double fault 경로를 분리해 이 부담을 줄입니다.
• 해결책: 깊은 재귀 대신 반복(Iteration)을 사용하고, 큰 로컬 변수는 힙에 할당합니다.

주의사항 및 버그 패턴

kthread_stop() 없이 모듈 언로드

/* 잘못된 예 — 스레드 실행 중 모듈 언로드 */
static void __exit bad_exit(void)
{
    /* kthread_stop() 호출 안 함!
     * → 스레드가 계속 실행되지만 코드 영역이 해제됨
     * → 커널 패닉 (use-after-free) */
    pr_info("goodbye\n");
}

/* 올바른 예 */
static void __exit good_exit(void)
{
    if (my_thread) {
        kthread_stop(my_thread);  /* 반드시 종료 대기 */
        my_thread = NULL;
    }
}

커널 스레드에서 유저 공간 접근

/* 잘못된 예 — 커널 스레드에서 유저 메모리 접근 */
static int bad_thread_fn(void *data)
{
    char __user *ubuf = (char __user *)data;
    char kbuf[64];

    /* mm == NULL이므로 copy_from_user()가 실패하거나 Oops 발생!
     * 커널 스레드는 유저 주소 공간이 없습니다 */
    copy_from_user(kbuf, ubuf, 64);  /* WRONG */

    return 0;
}

/* 올바른 방법: 데이터를 커널 메모리에 복사해서 전달 */
char *kdata = kmalloc(64, GFP_KERNEL);
copy_from_user(kdata, ubuf, 64);  /* 유저 컨텍스트에서 미리 복사 */
kth = kthread_run(my_fn, kdata, "my-kthread");  /* 커널 메모리 전달 */

무한 루프 / CPU 100% 점유

/* 잘못된 예 — 슬립 없는 폴링 루프 */
static int hog_thread_fn(void *data)
{
    while (!kthread_should_stop()) {
        /* CPU를 100% 점유! 다른 태스크 기아 발생 */
        do_polling();
    }
    return 0;
}

/* 올바른 예 — schedule() 또는 cond_resched() 삽입 */
static int good_thread_fn(void *data)
{
    while (!kthread_should_stop()) {
        if (!has_work()) {
            usleep_range(1000, 2000);  /* 1~2ms 슬립 */
            continue;
        }
        do_work();
        cond_resched();  /* 선점 포인트 */
    }
    return 0;
}

kthread_create 에러 미처리

/* 잘못된 예 */
my_thread = kthread_run(fn, data, "my-kth");
wake_up_process(my_thread);  /* IS_ERR일 때 크래시! */

/* 올바른 예 */
my_thread = kthread_run(fn, data, "my-kth");
if (IS_ERR(my_thread)) {
    pr_err("failed: %ld\n", PTR_ERR(my_thread));
    my_thread = NULL;  /* exit에서 NULL 체크 가능하도록 */
    return PTR_ERR(my_thread);
}

커널 스레드 보안 고려사항 (Security Considerations)

커널 스레드는 커널 모드에서 실행되므로 사용자 공간(User Space)의 보안 메커니즘(seccomp, 사용자 네임스페이스 등)이 적용되지 않습니다. 기본적으로 init_cred를 상속받아 완전한 root 권한으로 실행되기 때문에, 보안 측면에서 신중한 설계가 필요합니다.

기본 자격 증명 (Default Credentials)

/* 커널 스레드의 기본 자격 증명 */
/* kthreadd가 init_cred를 사용하므로 모든 자식도 상속 */
struct cred init_cred = {
    .usage           = ATOMIC_INIT(4),
    .uid             = GLOBAL_ROOT_UID,
    .gid             = GLOBAL_ROOT_GID,
    .cap_inheritable = CAP_FULL_SET,
    .cap_permitted   = CAP_FULL_SET,
    .cap_effective   = CAP_FULL_SET,
    ...
};

권한 제한 방법

prepare_kernel_cred()와 commit_creds()를 사용하면 커널 스레드의 capabilities를 필요한 최소한으로 제한할 수 있습니다.

/* 커널 스레드에서 권한 제한 */
static int secure_kthread(void *data)
{
    struct cred *new_cred;

    new_cred = prepare_kernel_cred(NULL);
    /* capabilities 제거 */
    cap_clear(new_cred->cap_effective);
    cap_clear(new_cred->cap_permitted);
    /* 특정 capability만 추가 */
    cap_raise(new_cred->cap_effective, CAP_NET_ADMIN);
    cap_raise(new_cred->cap_permitted, CAP_NET_ADMIN);

    commit_creds(new_cred);

    while (!kthread_should_stop()) {
        /* 이제 CAP_NET_ADMIN만 가진 상태로 실행 */
        do_network_work();
        schedule();
    }
    return 0;
}

보안 측면 요약

API 레퍼런스 요약

아래 표는 현재 메인라인 커널의 include/linux/kthread.h에 실제 선언된 심볼을 기준으로 정리한 것입니다. 시그니처 표기는 실제 헤더 정의와 일치하며, 매크로와 정적 인라인 함수(Inline Function)를 구분했습니다.

생성 및 수명 주기

정지와 park 제어

kthread_worker / kthread_work

상태 조회 및 컨텍스트 분리

kthread_worker 큐 처리

kthread_worker는 단일 스레드 기반의 작업 큐(Workqueue)로, 내부적으로 work_list에 연결된 kthread_work를 순차적으로 꺼내 실행합니다. 이 섹션에서는 큐 처리 메커니즘, 작업 생명주기, flush/cancel 동작을 상세히 분석합니다.

kthread_worker_fn() 내부 구현

kthread_worker_fn()은 워커 스레드의 메인 루프로, kthread_create_worker()가 자동으로 이 함수를 스레드 함수로 설정합니다:

/* kernel/kthread.c - kthread_worker_fn() 핵심 (간략화) */
int kthread_worker_fn(void *worker_ptr)
{
    struct kthread_worker *worker = worker_ptr;
    struct kthread_work *work;

repeat:
    set_current_state(TASK_INTERRUPTIBLE);

    if (kthread_should_stop()) {
        __set_current_state(TASK_RUNNING);
        raw_spin_lock_irq(&worker->lock);
        worker->task = NULL;
        raw_spin_unlock_irq(&worker->lock);
        return 0;
    }

    work = NULL;
    raw_spin_lock_irq(&worker->lock);
    if (!list_empty(&worker->work_list)) {
        work = list_first_entry(&worker->work_list,
                    struct kthread_work, node);
        list_del_init(&work->node);
    }
    worker->current_work = work;
    raw_spin_unlock_irq(&worker->lock);

    if (work) {
        __set_current_state(TASK_RUNNING);
        work->func(work);
    } else if (!freezing(current)) {
        schedule();
    }

    try_to_freeze();
    cond_resched();
    goto repeat;
}

flush와 cancel 의미론

kthread_flush_work()와 kthread_cancel_work_sync()는 작업 상태에 따라 다르게 동작합니다:

/* flush: 특정 work가 완료될 때까지 블록 */
kthread_queue_work(worker, &my_work);
kthread_flush_work(&my_work);
/* 이 시점에서 my_work의 func()가 확실히 완료됨 */

/* cancel: QUEUED 상태면 제거, EXECUTING이면 완료 대기 */
bool was_queued = kthread_cancel_work_sync(&my_work);
if (was_queued)
    pr_info("work was dequeued before execution\n");
else
    pr_info("work was not queued or already completed\n");

/* delayed work 취소 — 타이머와 큐 모두 처리 */
kthread_cancel_delayed_work_sync(&my_dwork);
/* 타이머가 아직 만료 전이면 타이머 취소 + true 반환
 * 이미 큐잉되었으면 큐에서 제거 + true 반환
 * 실행 중이면 완료 대기 + false 반환 */

Parking 상태 머신

kthread_park()/kthread_unpark()는 커널 스레드를 일시 중지/재개하는 메커니즘으로, CPU 핫플러그 처리에서 핵심적인 역할을 합니다. 내부적으로 KTHREAD_SHOULD_PARK 플래그와 completion parked의 조합으로 동기화합니다. 별도의 KTHREAD_IS_PARKED 플래그는 존재하지 않습니다.

park/unpark 내부 구현

/* kernel/kthread.c - park/unpark 내부 구현 (주석 축약, master 기준) */
int kthread_park(struct task_struct *k)
{
    struct kthread *kthread = to_kthread(k);

    if (WARN_ON(k->flags & PF_EXITING))
        return -ENOSYS;

    /* 이미 park 요청이 있으면 중복 park를 거부한다 */
    if (WARN_ON_ONCE(test_bit(KTHREAD_SHOULD_PARK, &kthread->flags)))
        return -EBUSY;

    /* SHOULD_PARK 비트 설정 */
    set_bit(KTHREAD_SHOULD_PARK, &kthread->flags);

    /* 자기 자신을 park하는 경로는 깨우기와 대기를 건너뛴다 */
    if (k != current) {
        /* 슬립 중이면 깨움 — should_park()를 확인하게 함 */
        wake_up_process(k);

        /* __kthread_parkme()이 complete() — TASK_PARKED 진입 직전 */
        wait_for_completion(&kthread->parked);

        /* schedule()까지 끝나 런큐에서 빠질 때까지 대기 */
        WARN_ON_ONCE(!wait_task_inactive(k, TASK_PARKED));
    }

    return 0;
}

/* __kthread_parkme() — 내부 함수, 스레드 자신이 호출 */
static void __kthread_parkme(struct kthread *self)
{
    for (;;) {
        /* TASK_PARKED는 특수 상태 — pending wakeup과 충돌 방지 */
        set_special_state(TASK_PARKED);
        if (!test_bit(KTHREAD_SHOULD_PARK, &self->flags))
            break;

        /* schedule() 진입 전 선점 금지 — wait_task_inactive() 보장 */
        preempt_disable();
        complete(&self->parked);
        schedule_preempt_disabled();
        preempt_enable();
    }
    __set_current_state(TASK_RUNNING);
}

/* kthread_parkme() — 외부 API (__kthread_parkme 래퍼) */
void kthread_parkme(void)
{
    __kthread_parkme(to_kthread(current));
}

/* kthread_unpark() — 외부에서 호출 */
void kthread_unpark(struct task_struct *k)
{
    struct kthread *kthread = to_kthread(k);

    /* SHOULD_PARK가 설정되어 있지 않으면 무시 */
    if (!test_bit(KTHREAD_SHOULD_PARK, &kthread->flags))
        return;

    /* per-CPU 스레드는 다시 CPU에 바인딩 */
    if (kthread_is_per_cpu(kthread))
        __kthread_bind(k, kthread->cpu, TASK_PARKED);

    /* SHOULD_PARK 해제 — __kthread_parkme 루프 탈출 조건 */
    clear_bit(KTHREAD_SHOULD_PARK, &kthread->flags);

    /* TASK_PARKED 상태에서 깨움 */
    wake_up_state(k, TASK_PARKED);
}

kthread_create_on_node() 코드 워크스루

커널 스레드 생성의 전체 경로를 kthread_create_on_node()부터 실제 태스크가 실행되기까지 단계별로 추적합니다.

__kthread_create_on_node() 상세

/* kernel/kthread.c - __kthread_create_on_node() (간략화) */
struct task_struct *__kthread_create_on_node(
    int (*threadfn)(void *data),
    void *data, int node,
    const char namefmt[], va_list args)
{
    DECLARE_COMPLETION_ONSTACK(done);
    struct task_struct *task;
    struct kthread_create_info *create;

    /* ① kthread_create_info 할당 및 초기화 */
    create = kmalloc(sizeof(*create), GFP_KERNEL);
    if (!create)
        return ERR_PTR(-ENOMEM);

    create->threadfn = threadfn;
    create->data = data;
    create->node = node;
    create->done = &done;
    vsnprintf(create->full_name, sizeof(create->full_name),
              namefmt, args);

    /* ② 리스트에 추가하고 kthreadd 깨움 */
    spin_lock(&kthread_create_lock);
    list_add_tail(&create->list, &kthread_create_list);
    spin_unlock(&kthread_create_lock);
    wake_up_process(kthreadd_task);

    /* ③ kthreadd가 생성 완료할 때까지 블록 */
    wait_for_completion_killable(&done);

    /* ④ 결과 회수 */
    task = create->result;
    kfree(create);

    if (!IS_ERR(task)) {
        /* NUMA 노드에 대한 스택 할당 최적화 */
        struct kthread *kthread = to_kthread(task);
        kthread->threadfn = threadfn;
        kthread->data = data;
    }
    return task;
}

스레드 시작 시퀀스

새로 생성된 커널 스레드의 kthread() 함수가 실행되는 과정을 더 자세히 살펴봅니다:

/* kernel/kthread.c - kthread() 시작 함수 상세 */
static int kthread(void *_create)
{
    struct kthread_create_info *create = _create;
    int (*threadfn)(void *data);
    void *data;
    int ret;

    /* ① kthread 메타데이터 초기화 */
    struct kthread *self = to_kthread(current);
    self->threadfn = create->threadfn;
    self->data = create->data;

    /* ② 생성 완료를 호출자에게 통지 */
    threadfn = create->threadfn;
    data = create->data;
    create->result = current;
    complete(create->done);
    /* 이 시점 이후 create를 참조하면 안 됨 — 호출자가 해제할 수 있음 */

    /* ③ wake_up_process()가 호출될 때까지 대기
     * kthread_run()이면 즉시 깨어남
     * kthread_create()면 호출자가 수동으로 깨울 때까지 대기 */
    schedule_preempt_disabled();

    /* ④ 실행 — stop 요청이 이미 있으면 건너뜀 */
    if (!test_bit(KTHREAD_SHOULD_STOP, &self->flags))
        ret = threadfn(data);
    else
        ret = -EINTR;

    kthread_exit(ret);
    /* 도달하지 않음 */
}

커널 소스 분석: 호출 체인 및 핵심 구조체(Struct)

이 절에서는 커널 스레드 생성과 실행의 전체 호출 체인(Call Chain)을 kthread_create_on_node()부터 threadfn() 실행까지 실제 소스 코드를 기반으로 분석합니다.

호출 체인 전체 흐름

struct kthread — 커널 스레드 내부 상태

struct kthread는 커널 스레드 한 개당 하나씩 할당되는 내부 메타데이터 구조체입니다. set_kthread_struct()가 kzalloc_obj()로 힙에 할당한 뒤 task_struct의 worker_private 포인터에 연결하므로, 태스크 스택 위에 놓이는 구조체가 아닙니다. to_kthread(task) 인라인 함수가 이 포인터를 반환하며, PF_KTHREAD 플래그가 없는 태스크에 대해서는 WARN_ON이 발생합니다.

/* kernel/kthread.c - struct kthread (master) */
struct kthread {
    unsigned long   flags;
    unsigned int    cpu;
    unsigned int    node;
    int             started;
    int             result;
    int             (*threadfn)(void *);
    void           *data;
    struct completion parked;
    struct completion exited;
#ifdef CONFIG_BLK_CGROUP
    struct cgroup_subsys_state *blkcg_css;
#endif
    /* To store the full name if task comm is truncated. */
    char            *full_name;
    struct task_struct *task;
    struct list_head affinity_node;
    struct cpumask     *preferred_affinity;
};

enum KTHREAD_BITS {
    KTHREAD_IS_PER_CPU = 0,
    KTHREAD_SHOULD_STOP,
    KTHREAD_SHOULD_PARK,
};

struct kthread_worker / kthread_work — 필드 상세

kthread_worker와 kthread_work는 전용 커널 스레드 기반의 작업 큐를 구성합니다. workqueue(CMWQ)와 달리 단일 스레드에서 순차 실행을 보장하며 실시간 우선순위 설정이 용이합니다.

/* include/linux/kthread.h - struct kthread_worker */
struct kthread_worker {
    unsigned int         flags;             /* KTW_FREEZABLE 등 플래그 */
    raw_spinlock_t       lock;              /* work_list 보호 스핀락 */
    struct list_head     work_list;         /* 실행 대기 중인 kthread_work 큐 */
    struct list_head     delayed_work_list;  /* 지연 실행 work 큐 (타이머 기반) */
    struct task_struct   *task;             /* 워커 스레드 task_struct */
    struct kthread_work  *current_work;     /* 현재 실행 중인 work (flush 동기화용) */
};

/* include/linux/kthread.h - struct kthread_work */
struct kthread_work {
    struct list_head      node;    /* work_list 연결용 리스트 노드 */
    kthread_work_func_t   func;    /* 실행할 작업 함수 포인터 */
    struct kthread_worker *worker; /* 이 work가 큐잉된 워커 (NULL이면 미큐잉) */
    int                   canceling; /* cancel 진행 중인 횟수 (atomic) */
};

kthreadd() 소스 분석

kthreadd()는 PID 2로 실행되며, kthread_create_list를 감시하다가 요청이 들어오면 create_kthread()를 호출하여 실제 커널 스레드를 생성합니다.

/* kernel/kthread.c */
int kthreadd(void *unused)
{
    struct task_struct *tsk = current;  /* 현재 태스크 = kthreadd 자신 */

    /* 모든 CPU에서 실행 가능하도록 설정 (housekeeping CPU 집합) */
    set_cpus_allowed_ptr(tsk, housekeeping_cpumask(HK_TYPE_KTHREAD));
    set_mems_allowed(node_states[N_MEMORY]);  /* 모든 NUMA 노드 허용 */

    current->flags |= PF_NOFREEZE;  /* freezer 대상 제외: kthreadd는 항상 실행 */
    cgroup_init_kthreadd();          /* cgroup 초기화 */
    ignore_signals(tsk);             /* 모든 시그널 무시 */

    for (;;) {
        set_current_state(TASK_INTERRUPTIBLE); /* 슬립 준비 */

        if (list_empty(&kthread_create_list))
            schedule();  /* 요청 없음 → CPU 양보, 깨어날 때까지 대기 */

        __set_current_state(TASK_RUNNING);  /* RUNNING 복귀 */

        spin_lock(&kthread_create_lock);
        while (!list_empty(&kthread_create_list)) {
            struct kthread_create_info *create;

            create = list_entry(kthread_create_list.next,
                                struct kthread_create_info,
                                list);
            list_del_init(&create->list);   /* 리스트에서 분리 */
            spin_unlock(&kthread_create_lock);

            create_kthread(create);          /* 실제 스레드 생성 */

            spin_lock(&kthread_create_lock);
        }
        spin_unlock(&kthread_create_lock);
    }

    return 0;  /* 도달하지 않음 */
}

kthread() 래퍼 소스 분석

kthread()는 모든 커널 스레드의 실제 진입점(Entry Point)입니다. kernel_clone()으로 생성된 태스크가 가장 먼저 이 함수를 실행합니다.

/* kernel/kthread.c - kthread() 래퍼 (실제 커널 스레드 진입점) */
static int kthread(void *_create)
{
    static const struct sched_param param = { .sched_priority = 0 };
    struct kthread_create_info *create = _create;
    int (*threadfn)(void *data) = create->threadfn;
    void *data                  = create->data;
    struct completion *done;
    struct kthread *self;
    int ret;

    self = to_kthread(current);

    /* done을 원자적으로 교환 — 호출자가 치명적 시그널로 죽은 경우 NULL */
    done = xchg(&create->done, NULL);
    if (!done) {
        kfree(create->full_name);
        kfree(create);
        kthread_exit(-EINTR);
    }

    self->full_name = create->full_name;
    self->threadfn = threadfn;
    self->data = data;

    /* kthreadd의 스케줄링 정책/CPUMask를 기본값으로 복원 */
    sched_setscheduler_nocheck(current, SCHED_NORMAL, &param);

    /* 호출자에게 task_struct 포인터 전달 + 완료 통지 */
    __set_current_state(TASK_UNINTERRUPTIBLE);
    create->result = current;
    preempt_disable();
    complete(done);
    schedule_preempt_disabled();
    preempt_enable();

    self->started = 1;  /* 첫 wake-up 완료 표시 */

    /* kthread_bind()나 kthread_affine_preferred()가 호출되지 않았다면
     * housekeeping CPU에 대한 기본 어피니티 적용 */
    if (!(current->flags & PF_NO_SETAFFINITY) && !self->preferred_affinity)
        kthread_affine_node();

    ret = -EINTR;
    if (!test_bit(KTHREAD_SHOULD_STOP, &self->flags)) {
        cgroup_kthread_ready();
        __kthread_parkme(self);  /* park 요청 처리 (CPU hotplug 연동) */
        ret = threadfn(data);
    }
    kthread_exit(ret);
}

kthread_worker_fn() 소스 분석

kthread_worker_fn()은 kthread_create_worker()가 내부적으로 생성하는 전용 워커 스레드의 메인 루프입니다. work_list에서 작업을 꺼내어 순차 실행합니다.

/* kernel/kthread.c - kthread_worker_fn() */
int kthread_worker_fn(void *worker_ptr)
{
    struct kthread_worker *worker = worker_ptr;
    struct kthread_work   *work;

    WARN_ON(worker->task);              /* 중복 실행 방지 */
    worker->task = current;

repeat:
    set_current_state(TASK_INTERRUPTIBLE);  /* 슬립 준비 */

    if (kthread_should_stop()) {           /* stop 요청 확인 */
        __set_current_state(TASK_RUNNING);
        break;
    }

    work = NULL;
    raw_spin_lock_irq(&worker->lock);
    if (!list_empty(&worker->work_list)) {
        work = list_first_entry(&worker->work_list,
                               struct kthread_work, node);
        list_del_init(&work->node);     /* 큐에서 분리 */
    }
    worker->current_work = work;        /* flush 동기화를 위해 기록 */
    raw_spin_unlock_irq(&worker->lock);

    if (work) {
        __set_current_state(TASK_RUNNING);
        work->func(work);              /* 작업 실행 */
        cond_resched();                /* 선점 포인트: 다른 태스크에 양보 */
    } else {
        schedule();                   /* 할 일 없음 → 슬립 */
    }

    goto repeat;
}
EXPORT_SYMBOL_GPL(kthread_worker_fn);

kthread_worker_fn() 실행 흐름

Freezer 연동

시스템 절전(suspend/hibernate) 시 커널의 freezer는 모든 유저 프로세스와 freezable 커널 스레드를 동결합니다. I/O를 수행하는 커널 스레드가 suspend 도중 디스크에 접근하면 데이터 손상이 발생할 수 있으므로, freezer 연동은 전원 관리(Power Management)의 핵심입니다.

Freezer API 상세

/* freezer 연동 패턴 — I/O 스레드에서 권장 */
static int io_thread_fn(void *data)
{
    set_freezable();

    while (!kthread_should_stop()) {
        /* 방법 1: wait_event_freezable (가장 권장) */
        wait_event_freezable(wq,
            has_work || kthread_should_stop());

        if (kthread_should_stop())
            break;

        do_io_work();
    }
    return 0;
}

/* 방법 2: 수동 try_to_freeze() */
static int polling_thread_fn(void *data)
{
    set_freezable();

    while (!kthread_should_stop()) {
        /* 루프 시작마다 freeze 확인 */
        try_to_freeze();

        if (check_condition()) {
            process_data();
        }
        usleep_range(1000, 2000);
    }
    return 0;
}

/* 방법 3: kthread_freezable_should_stop() */
while (!kthread_freezable_should_stop(NULL)) {
    /* freeze + stop 동시 확인 */
    do_work();
    schedule();
}

커널 스레드 시그널 처리

커널 스레드는 유저 프로세스와 달리 대부분의 시그널을 무시합니다. 대신 kthread_should_stop()과 kthread_should_park()라는 커널 내부 플래그 기반의 제어 메커니즘을 사용합니다.

시그널 차단 메커니즘

/* kthreadd가 생성하는 모든 커널 스레드의 시그널 마스크 */
/* kernel/kthread.c - kthreadd() */
ignore_signals(current);
/* → sigfillset(¤t->blocked) — 모든 시그널 차단 */

/* 자식 스레드(새로 생성되는 kthread)도 이 마스크를 상속
 * → 기본적으로 모든 커널 스레드는 시그널 전달 불가 */

kthread 제어 플래그

/* 올바른 제어 플래그 확인 패턴 */
static int well_behaved_fn(void *data)
{
    while (!kthread_should_stop()) {
        /* park 요청 먼저 확인 — CPU offline 대응 */
        if (kthread_should_park()) {
            kthread_parkme();
            continue;  /* unpark 후 루프 재진입 */
        }

        /* 실제 작업 */
        do_work();
        schedule();
    }
    return 0;
}

/* 시그널 허용이 필요한 특수한 경우 */
static int signal_aware_fn(void *data)
{
    /* 특정 시그널만 허용 (매우 드문 패턴) */
    allow_signal(SIGTERM);
    allow_signal(SIGKILL);

    while (!kthread_should_stop()) {
        if (signal_pending(current)) {
            flush_signals(current);
            pr_info("signal received, cleaning up\n");
            break;
        }
        do_work();
        msleep_interruptible(1000);
    }
    return 0;
}

stop vs park vs signal 비교

ftrace/bpftrace 커널 스레드 모니터링

커널 스레드의 실행 패턴, 스케줄링 동작, 성능 특성을 분석하기 위해 ftrace와 bpftrace를 활용할 수 있습니다.

sched 트레이스포인트 활용

# kthread 관련 주요 트레이스포인트
ls /sys/kernel/debug/tracing/events/sched/
# sched_kthread_stop         — kthread_stop() 호출 시
# sched_kthread_stop_ret     — kthread_stop() 완료 시 (반환값 포함)
# sched_kthread_work_execute_start  — kthread_work 실행 시작
# sched_kthread_work_execute_end    — kthread_work 실행 완료
# sched_kthread_work_queue_work     — kthread_work 큐잉 시

# 특정 커널 스레드의 스케줄링 이벤트 추적
cd /sys/kernel/debug/tracing
echo 0 > tracing_on
echo > trace
echo 1 > events/sched/sched_switch/enable
echo 1 > events/sched/sched_wakeup/enable

# ksoftirqd만 필터링
echo 'comm == "ksoftirqd/0"' > events/sched/sched_switch/filter
echo 1 > tracing_on
sleep 5
echo 0 > tracing_on
cat trace

# 출력 예시:
#  ksoftirqd/0-12  [000] ..s.  123.456: sched_switch: prev_comm=ksoftirqd/0
#    prev_pid=12 prev_prio=120 prev_state=S ==> next_comm=swapper/0

kthread_work 추적

# kthread_worker의 작업 실행 추적
echo 1 > events/sched/sched_kthread_work_queue_work/enable
echo 1 > events/sched/sched_kthread_work_execute_start/enable
echo 1 > events/sched/sched_kthread_work_execute_end/enable
echo 1 > tracing_on
sleep 10
echo 0 > tracing_on
cat trace

# 작업 지연 분석: queue → execute_start 사이의 시간 측정
cat trace | grep kthread_work | awk '{print $1, $4, $5}'

bpftrace 원라이너

# 커널 스레드 생성 추적
bpftrace -e 'kprobe:kthread_create_on_node {
    printf("kthread create: %s (comm=%s, pid=%d)\n",
           str(arg3), comm, pid);
}'

# kthread_stop 호출 추적 (누가 어떤 스레드를 정지시키는지)
bpftrace -e 'kprobe:kthread_stop {
    $task = (struct task_struct *)arg0;
    printf("stop kthread: pid=%d comm=%s by %s(%d)\n",
           $task->pid, $task->comm, comm, pid);
}'

# kthread_worker 작업 실행 시간 히스토그램
bpftrace -e '
tracepoint:sched:sched_kthread_work_execute_start {
    @start[tid] = nsecs;
}
tracepoint:sched:sched_kthread_work_execute_end {
    if (@start[tid]) {
        @us = hist((nsecs - @start[tid]) / 1000);
        delete(@start[tid]);
    }
}'

# 커널 스레드 웨이크업 지연 측정 (깨어나기까지 걸린 시간)
bpftrace -e '
tracepoint:sched:sched_wakeup /args->comm == "ksoftirqd/0"/ {
    @wakeup[args->comm] = nsecs;
}
tracepoint:sched:sched_switch /args->next_comm == "ksoftirqd/0"/ {
    if (@wakeup["ksoftirqd/0"]) {
        $delay = nsecs - @wakeup["ksoftirqd/0"];
        printf("ksoftirqd/0 wakeup-to-run latency: %d us\n", $delay / 1000);
        delete(@wakeup["ksoftirqd/0"]);
    }
}'

perf를 활용한 kthread 분석

# 커널 스레드의 스케줄링 지연 분석
perf sched record -- sleep 30
perf sched latency --sort max
# Task                  |   Runtime   |  Switches  |  Avg delay  |  Max delay
# ksoftirqd/0:12        |    5.234 ms |       142  |   0.045 ms  |   1.234 ms

# 특정 kworker의 함수 프로파일
perf record -p $(pgrep -f 'kworker/0:1$') -g -- sleep 10
perf report --stdio

# kthread_stop 이벤트 카운팅
perf stat -e 'sched:sched_kthread_stop' -a -- sleep 60

# off-CPU 분석 — kthread가 어디서 블록되는지
perf record -e sched:sched_switch -a --filter 'prev_comm ~ "kswapd*"' -- sleep 30
perf script

디자인 패턴 비교 및 선택 가이드

리눅스 커널은 비동기 작업 처리를 위해 여러 메커니즘을 제공합니다. 각각의 특성을 이해하고 상황에 맞는 최적의 선택을 하는 것이 중요합니다.

메커니즘 종합 비교

사용 사례별 권장 패턴

/* 패턴 1: 단순 비동기 작업 → workqueue (가장 간단) */
static void simple_work_fn(struct work_struct *work)
{
    do_deferred_init();
}
static DECLARE_WORK(init_work, simple_work_fn);
schedule_work(&init_work);

/* 패턴 2: 순차 보장 → kthread_worker */
struct kthread_worker *w = kthread_create_worker(0, "serial-io");
kthread_init_work(&my_work, serial_io_fn);
kthread_queue_work(w, &my_work);

/* 패턴 3: 복잡한 상태 머신 → kthread_run() */
kthread_run(complex_state_machine_fn, dev, "my-daemon");

/* 패턴 4: per-CPU 처리 → smpboot */
static struct smp_hotplug_thread my_threads = {
    .store             = &per_cpu_task,
    .thread_should_run = my_should_run,
    .thread_fn         = my_per_cpu_fn,
    .thread_comm       = "mythread/%u",
};
smpboot_register_percpu_thread(&my_threads);

참고자료

커널 공식 문서

• Kernel Thread API — kernel.org — kthread_run, kthread_create, kthread_stop 등 커널 스레드 공식 API 레퍼런스입니다
• Concurrency Managed Workqueue (cmwq) — kernel.org — 커널 스레드 대안으로 권장되는 CMWQ 프레임워크 공식 문서입니다
• Kernel Sysctl Parameters — kernel.org — kthread_cpus 등 커널 스레드 관련 sysctl 튜닝 매개변수를 설명합니다

LWN.net 기사

• The kthread API (LWN, 2004) — kthread_create/kthread_stop API 도입 배경과 kernel_thread() 대비 개선점을 다룬 기사입니다
• Concurrency-managed workqueues (LWN, 2010) — 커널 스레드 직접 생성 대신 워크큐를 활용하는 CMWQ 설계 동기를 설명합니다
• The kthread_worker API (LWN, 2012) — kthread_worker/kthread_work 인프라의 도입과 활용 방법을 소개합니다
• Freezing and thawing kernel threads (LWN, 2005) — 시스템 절전(suspend) 시 커널 스레드 동결(freeze) 메커니즘을 다룹니다
• kthread_should_stop() and wakeups (LWN, 2007) — 커널 스레드 종료 처리 시 kthread_should_stop()과 웨이크업 경합 문제를 설명합니다
• Bounding kernel threads to CPUs (LWN, 2015) — kthread_bind와 CPU 어피니티 설정을 통한 커널 스레드 CPU 격리 기법을 다룹니다

커널 소스 코드

• kernel/kthread.c — kthread_create_on_node, kthread_worker_fn 등 커널 스레드 핵심 구현체입니다
• include/linux/kthread.h — kthread_run, kthread_worker, kthread_work 등 핵심 매크로와 구조체 정의입니다
• include/linux/smpboot.h — smp_hotplug_thread 구조체와 smpboot_register_percpu_thread 등 per-CPU 스레드 프레임워크 정의입니다
• kernel/smpboot.c — per-CPU 커널 스레드의 hotplug 관리와 park/unpark 구현입니다
• kthread_worker_fn() — kernel/kthread.c — kthread_worker 메인 루프 구현으로, work 큐잉과 실행 흐름을 확인할 수 있습니다

서적

• Linux Kernel Development, 3rd Edition (Robert Love, Addison-Wesley, 2010) — Chapter 3 "Process Management"에서 커널 스레드 생성과 관리를 설명합니다
• Linux Device Drivers, 3rd Edition (Corbet, Rubini, Kroah-Hartman, O'Reilly, 2005) — Chapter 7 "Time, Delays, and Deferred Work"에서 커널 스레드 기반 작업 처리를 다룹니다
• Understanding the Linux Kernel, 3rd Edition (Bovet & Cesati, O'Reilly, 2005) — Chapter 3 "Processes"에서 커널 스레드의 내부 구조와 스케줄링을 상세히 설명합니다
• Professional Linux Kernel Architecture (Wolfgang Mauerer, Wrox, 2008) — 커널 스레드의 생성 과정과 kthreadd 데몬의 역할을 분석합니다