CPU Hotplug

리눅스 커널의 CPU 온라인/오프라인 메커니즘을 상태 머신부터 아키텍처별 구현, 서브시스템 연동, 실전 활용까지 심층 분석합니다.

CPU Hotplug 입문 가이드

CPU를 왜 끌까요? 실무에서 CPU Hotplug을 사용하는 대표적인 이유는 다음과 같습니다.

가장 기본적인 실습부터 시작합니다.

# 현재 CPU 상태 확인
lscpu | grep -E "^CPU\(s\)|On-line|Off-line"
# CPU(s):                  8
# On-line CPU(s) list:     0-7

# CPU 3 오프라인
echo 0 > /sys/devices/system/cpu/cpu3/online

# 상태 확인
cat /sys/devices/system/cpu/online   # 0-2,4-7
cat /sys/devices/system/cpu/offline  # 3

# 오프라인 전후 인터럽트 분포 비교
cat /proc/interrupts | head -5
#            CPU0       CPU1       CPU2       CPU3       CPU4 ...
# 오프라인 후 CPU3 컬럼 없음 → IRQ가 다른 CPU로 재분배됨

# softirq 변화 확인
cat /proc/softirqs | head -5
# CPU3 컬럼의 카운터가 더 이상 증가하지 않음

# CPU 온라인 복원
echo 1 > /sys/devices/system/cpu/cpu3/online

# 전체 CPU 일괄 온라인 복원
for cpu in /sys/devices/system/cpu/cpu[0-9]*; do
    [ -f "$cpu/online" ] && echo 1 > "$cpu/online" 2>/dev/null
done

CPU Hotplug 개요

CPU Hotplug은 시스템 실행 중에 논리 CPU를 온라인(online) 또는 오프라인(offline) 상태로 전환하는 커널 메커니즘입니다. 물리적 CPU 제거 없이도 논리적으로 CPU를 비활성화할 수 있으며, 다음과 같은 사용 사례가 있습니다.

커널은 CPU 상태를 4가지 비트마스크로 관리합니다.

/* include/linux/cpumask.h */
extern struct cpumask __cpu_possible_mask;  /* 사용할 수 있는 CPU 번호의 상한 */
extern struct cpumask __cpu_present_mask;   /* 물리적으로 존재 */
extern struct cpumask __cpu_online_mask;    /* 스케줄러에 참여 중 */
extern struct cpumask __cpu_active_mask;    /* 마이그레이션 대상 가능 */

/* 사용 예 */
for_each_online_cpu(cpu) {
    /* 온라인 CPU 순회 */
}

CPU 오프라인 시 처리해야 할 자원

CPU를 오프라인으로 전환하는 것은 단순히 "코어 전원을 끄는" 작업이 아닙니다. 해당 논리 CPU에 묶여 있던 모든 커널 자원을 다른 CPU로 안전하게 이관하거나 정리해야 합니다. 이 과정을 빠뜨리면 시스템 패닉, 데이터 유실, 영구 행(hang)이 발생할 수 있습니다. 아래에서는 "무엇을", "왜", "어떻게" 정리하는지를 살펴봅니다.

이 자원들의 정리 순서도 중요합니다. 예를 들어 태스크를 이관하기 전에 IRQ 어피니티를 먼저 변경하면, 이관 중인 태스크가 인터럽트를 수신하지 못하는 짧은 구간이 생길 수 있습니다. Linux 커널은 이 순서를 cpuhp 상태 머신을 통해 엄격하게 제어합니다. 각 자원 처리가 정확히 어느 단계(Prepare / Starting / Online)에서 일어나는지는 다음 절에서 설명합니다.

CPU Hotplug 아키텍처

CPU Hotplug의 핵심은 cpuhp 상태 머신(state machine)입니다. CPU가 CPUHP_OFFLINE에서 CPUHP_ONLINE으로 전이할 때, 중간의 각 상태에서 등록된 콜백이 순차적으로 호출됩니다. 오프라인은 역순으로 콜백이 호출됩니다.

왜 Prepare·Starting·Online 3단계인가

3단계 구분의 핵심은 "어느 CPU에서 실행되는가"와 "슬립(Sleep)이 허용되는가" 두 가지 축의 조합입니다. 각 단계는 이 두 축에 따라 수행할 수 있는 작업이 근본적으로 달라집니다.

Starting 단계의 제약: IRQ가 비활성화된 원자적 컨텍스트이므로 GFP_KERNEL 메모리 할당이나 mutex_lock() 같은 슬립 가능 연산은 사용할 수 없습니다. Starting 콜백은 반드시 GFP_ATOMIC 또는 사전 할당된 메모리만 사용해야 합니다. 이 제약을 어기면 커널 워닝(might_sleep()) 또는 데드락이 발생합니다. Prepare 단계에서 메모리를 미리 할당하는 이유가 바로 이것입니다.

/* include/linux/cpuhotplug.h — 주요 상태 (발췌) */
enum cpuhp_state {
    CPUHP_INVALID        = -1,
    CPUHP_OFFLINE        = 0,
    /* --- Prepare 콜백 (제어 CPU에서 실행) --- */
    CPUHP_CREATE_THREADS,
    CPUHP_PERF_PREPARE,
    CPUHP_WORKQUEUE_PREP,
    CPUHP_HRTIMERS_PREPARE,
    /* ... */
    CPUHP_BRINGUP_CPU,
    /* --- 여기서 타겟 CPU가 깨어남 --- */
    /* --- Starting 콜백 (타겟 CPU에서 실행, IRQ 비활성) --- */
    CPUHP_AP_IDLE_DEAD,
    CPUHP_AP_OFFLINE,
    CPUHP_AP_SCHED_STARTING,
    CPUHP_AP_RCUTREE_DYING,
    CPUHP_AP_IRQ_GIC_STARTING,
    /* ... */
    CPUHP_AP_ONLINE,
    /* --- Online 콜백 (타겟 CPU에서 실행, IRQ 활성) --- */
    CPUHP_AP_ACTIVE,
    CPUHP_AP_SMPBOOT_THREADS,
    CPUHP_AP_ONLINE_DYN,
    /* ... */
    CPUHP_ONLINE,
};

상태 머신의 핵심 원칙: bring-up 시 상태 번호가 증가하며 각 상태의 startup 콜백이 호출되고, teardown 시 역순으로 teardown 콜백이 호출됩니다. 어느 콜백이든 실패하면 이미 수행된 콜백을 역순으로 롤백(undo)합니다.

상태 머신

cpuhp 상태는 크게 3개 영역으로 나뉩니다.

/* kernel/cpu.c — 상태 배열 */
static struct cpuhp_step cpuhp_hp_states[] = {
    [CPUHP_OFFLINE] = {
        .name = "offline",
    },
    [CPUHP_CREATE_THREADS] = {
        .name = "threads:prepare",
        .startup.single = smpboot_create_threads,
        .teardown.single = NULL,
    },
    /* ... 수십 개의 상태 ... */
    [CPUHP_ONLINE] = {
        .name = "online",
    },
};

CPU Bring-up 과정

사용자가 echo 1 > /sys/devices/system/cpu/cpu3/online을 실행하면 다음 경로를 따릅니다.

/* kernel/cpu.c — bring-up 핵심 */
static int _cpu_up(unsigned int cpu, int tasks_frozen,
                   enum cpuhp_state target)
{
    struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
    int ret;

    cpus_write_lock();  /* percpu rwsem 쓰기 잠금 */

    /* Prepare 단계: 제어 CPU에서 콜백 실행 */
    for (st->state++; st->state < CPUHP_BRINGUP_CPU; st->state++) {
        ret = cpuhp_invoke_callback(cpu, st->state, true, NULL);
        if (ret)
            goto rollback;
    }

    /* 아키텍처별 CPU 시작 */
    ret = __cpu_up(cpu, idle_thread_get(cpu));
    if (ret)
        goto rollback;

    /* 타겟 CPU에서 Starting + Online 콜백 처리 */
    ret = bringup_wait_for_ap_online(st);

    cpus_write_unlock();
    return ret;
}

CPU Teardown 과정

echo 0 > /sys/devices/system/cpu/cpu3/online은 bring-up의 역순입니다. 핵심 작업은 태스크 마이그레이션, IRQ 재분배, 타이머 이동입니다.

/* kernel/cpu.c — teardown 핵심 */
static int __ref _cpu_down(unsigned int cpu, int tasks_frozen,
                           enum cpuhp_state target)
{
    /* 1. cpu_active_mask에서 제거 → 새 태스크 배치 차단 */
    set_cpu_active(cpu, false);

    /* 2. 마이그레이션: 실행 가능한 태스크를 다른 CPU로 이동 */
    sched_cpu_deactivate(cpu);

    /* 3. Online 콜백 역순 호출 (IRQ 활성 상태) */
    cpuhp_down_callbacks(cpu, st, target);

    /* 4. Starting 콜백 역순 (IRQ 비활성) */
    /* 5. 아키텍처별 CPU 정지 */
    /* 6. cpu_online_mask에서 제거 */
    set_cpu_online(cpu, false);

    /* 7. Prepare 콜백 역순 호출 (제어 CPU에서) */
}

콜백 등록

드라이버와 서브시스템은 cpuhp_setup_state() 계열 함수로 hotplug 콜백을 등록합니다.

/* 정적 상태에 콜백 등록 */
ret = cpuhp_setup_state(CPUHP_AP_PERF_X86_STARTING,
                        "perf/x86:starting",
                        x86_pmu_starting_cpu,   /* startup 콜백 */
                        x86_pmu_dying_cpu);      /* teardown 콜백 */

/* 동적 상태에 등록 (슬롯 자동 할당) */
ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN,
                        "my_driver:online",
                        my_online_cb, my_offline_cb);
/* ret > 0 이면 할당된 상태 번호 */

/* 인스턴스 기반: 여러 인스턴스 각각에 콜백 */
ret = cpuhp_setup_state_multi(CPUHP_AP_ONLINE_DYN,
                              "net/mlx5:online",
                              mlx5e_cpu_online,
                              mlx5e_cpu_offline);
/* cpuhp_state_add_instance()로 인스턴스 추가 */

sysfs 인터페이스

사용자 공간에서 CPU Hotplug을 제어하는 주요 sysfs 경로입니다.

# CPU 상태 확인
cat /sys/devices/system/cpu/online       # 예: 0-7
cat /sys/devices/system/cpu/offline      # 예: 8-15
cat /sys/devices/system/cpu/possible     # 예: 0-255
cat /sys/devices/system/cpu/present      # 예: 0-15

# CPU 3 오프라인
echo 0 > /sys/devices/system/cpu/cpu3/online

# CPU 3 온라인
echo 1 > /sys/devices/system/cpu/cpu3/online

# hotplug 상태 머신 디버그 정보
ls /sys/devices/system/cpu/hotplug/
# states — 전체 cpuhp 상태 목록과 현재 등록된 콜백
cat /sys/devices/system/cpu/hotplug/states | head -20

태스크 마이그레이션

CPU가 오프라인되면, 해당 CPU의 런큐(Runqueue)에 있는 모든 태스크를 다른 CPU로 이동해야 합니다.

/* kernel/sched/core.c — 폴백 런큐 선택 */
static int select_fallback_rq(int cpu, struct task_struct *p)
{
    int nid = cpu_to_node(cpu);
    const struct cpumask *nodemask;

    /* 1순위: 같은 NUMA 노드의 활성 CPU */
    nodemask = cpumask_of_node(nid);
    for_each_cpu(dest_cpu, nodemask) {
        if (cpumask_test_cpu(dest_cpu, &p->cpus_mask) &&
            cpu_active(dest_cpu))
            return dest_cpu;
    }

    /* 2순위: 아무 활성 CPU */
    /* 3순위: affinity 무시하고 아무 CPU (최후 수단) */
    do_set_cpus_allowed(p, cpu_possible_mask);
    dest_cpu = cpumask_any(cpu_active_mask);
    return dest_cpu;
}

인터럽트 처리

CPU 오프라인 시 해당 CPU에 설정된 인터럽트 affinity를 다른 CPU로 재분배해야 합니다.

/* kernel/irq/cpuhotplug.c */
void irq_migrate_all_off_this_cpu(void)
{
    struct irq_desc *desc;
    unsigned int irq;

    for_each_active_irq(irq) {
        desc = irq_to_desc(irq);
        /* managed IRQ: 해당 CPU 전용이면 셧다운 */
        if (irqd_affinity_is_managed(&desc->irq_data)) {
            irq_force_complete_move(desc);
            continue;
        }
        /* 일반 IRQ: 다른 온라인 CPU로 이동 */
        if (cpumask_test_cpu(smp_processor_id(), desc->irq_common_data.affinity))
            irq_set_affinity_locked(desc, cpu_online_mask, true);
    }
}

타이머 마이그레이션 (요약)

오프라인 CPU에 등록된 타이머는 다른 CPU로 이동해야 합니다.

/* kernel/time/hrtimer.c — hrtimer 마이그레이션 */
int hrtimers_cpu_dying(unsigned int dying_cpu)
{
    struct hrtimer_cpu_base *old_base, *new_base;
    int i;

    old_base = this_cpu_ptr(&hrtimer_bases);
    new_base = &per_cpu(hrtimer_bases, cpumask_first(cpu_active_mask));

    /* 모든 클록 베이스의 타이머를 이동 */
    for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {
        migrate_hrtimer_list(&old_base->clock_base[i],
                             &new_base->clock_base[i]);
    }
    return 0;
}

/* kernel/time/timer.c — timer wheel 마이그레이션 */
int timers_dead_cpu(unsigned int cpu)
{
    struct timer_base *old_base = per_cpu_ptr(&timer_bases[BASE_STD], cpu);
    struct timer_base *new_base = per_cpu_ptr(&timer_bases[BASE_STD],
                                             smp_processor_id());
    migrate_timer_list(new_base, old_base->vectors);
    return 0;
}

RCU와 CPU Hotplug

RCU는 CPU Hotplug과 긴밀하게 연동됩니다. 오프라인되는 CPU는 RCU의 관점에서 정지 상태(quiescent state)를 보고해야 하며, 진행 중인 grace period를 완료해야 합니다.

/* kernel/rcu/tree_plugin.h */
int rcutree_dying_cpu(unsigned int cpu)
{
    /* CPUHP_AP_RCUTREE_DYING 상태에서 호출 */
    /* 1. 보류 중인 RCU 콜백 다른 CPU로 이동 */
    rcu_migrate_callbacks(cpu);

    /* 2. rcu_node에서 해당 CPU 비트 제거 */
    rnp = rdp->mynode;
    mask = rdp->grpmask;
    raw_spin_lock_irqsave(&rnp->lock, flags);
    rnp->qsmaskinitnext &= ~mask;  /* 다음 GP에서 제외 */
    raw_spin_unlock_irqrestore(&rnp->lock, flags);
    return 0;
}

int rcutree_online_cpu(unsigned int cpu)
{
    /* CPU 온라인 시: rcu_node에 비트 설정 */
    rnp->qsmaskinitnext |= mask;
    return 0;
}

Workqueue 처리

Per-CPU workqueue의 worker 풀은 CPU Hotplug에 따라 관리됩니다.

/* kernel/workqueue.c */
/* CPU 오프라인 시: bound pool의 worker를 unbound pool로 이동 */
static void wq_worker_dying(struct worker *worker)
{
    /* 보류 중인 work item을 다른 CPU 풀로 이동 */
    list_for_each_entry_safe(work, n, &pool->worklist, entry) {
        move_linked_works(work, &pool->worklist, NULL);
    }
}

/* CPU 온라인 시 */
static int workqueue_online_cpu(unsigned int cpu)
{
    /* bound worker pool 재활성화 */
    /* unbound pool의 CPU affinity 갱신 */
}

RCU Grace Period

CPU가 오프라인될 때 RCU 서브시스템은 복잡한 절차를 거칩니다. 단순히 콜백을 이동하는 것만이 아니라, 진행 중인 grace period가 해당 CPU의 quiescent state 보고를 기다리고 있을 수 있으므로, 죽어가는 CPU가 명시적으로 QS를 보고해야 합니다.

RCU의 CPU 오프라인 처리는 크게 세 단계로 진행됩니다.

/* kernel/rcu/tree.c — CPU dead 보고 */
void rcu_report_dead(unsigned int cpu)
{
    struct rcu_data *rdp = per_cpu_ptr(&rcu_data, cpu);
    struct rcu_node *rnp = rdp->mynode;
    unsigned long mask = rdp->grpmask;

    /* 1단계: 현재 진행 중인 GP에 대해 QS 보고 */
    rcu_report_qs_rdp(rdp);

    /* 2단계: rcu_node에서 해당 CPU 비트 제거 */
    raw_spin_lock_irqsave_rcu_node(rnp, flags);
    rnp->qsmaskinitnext &= ~mask;
    raw_spin_unlock_irqrestore_rcu_node(rnp, flags);

    /* 3단계: 미처리 콜백이 있으면 orphan 큐로 이동 */
    rdp->cpu_started = false;
}

RCU NOCB 설정 — 콜백 오프로드

• 부팅 파라미터: rcu_nocbs=2-7
• 커널 6.2+ 동적 전환: echo 1 > /sys/devices/system/cpu/cpu3/rcu_nocb

NOCB CPU의 콜백 처리 kthread는 다음과 같습니다.

• rcuog/N — grace period 감시
• rcuop/N — 콜백 실행
• ps aux | grep rcu 명령으로 확인할 수 있습니다.

# RCU 상태 확인
cat /sys/kernel/debug/rcu/rcu_preempt/rcudata
# CPU별 completed GP, pending 콜백 수 확인

# NOCB 상태 확인
cat /sys/kernel/debug/rcu/rcu_preempt/rcudata | grep -E "nocb|offload"

# grace period 통계
cat /sys/kernel/debug/rcu/rcu_preempt/rcugp
# completed=N gpnum=M → N != M이면 GP 진행 중

타이머 마이그레이션

CPU가 오프라인될 때 해당 CPU에 등록된 모든 타이머를 안전하게 이동해야 합니다. Linux 커널은 hrtimer(고해상도 타이머(hrtimer))와 timer wheel(전통적 타이머) 두 가지 타이머 체계를 사용하며, 각각 별도의 마이그레이션 경로를 갖습니다.

/* kernel/time/hrtimer.c — hrtimer 마이그레이션 상세 */
static void migrate_hrtimer_list(
    struct hrtimer_clock_base *old_base,
    struct hrtimer_clock_base *new_base)
{
    struct hrtimer *timer;
    struct timerqueue_node *node;

    /* RB-tree의 모든 타이머를 순회 */
    while ((node = timerqueue_getnext(&old_base->active))) {
        timer = container_of(node, struct hrtimer, node);
        /* old_base에서 제거 */
        __remove_hrtimer(timer, old_base, HRTIMER_STATE_MIGRATE);
        timer->base = new_base;
        /* new_base에 삽입 (만료 시각 유지) */
        enqueue_hrtimer(timer, new_base, HRTIMER_MODE_ABS);
    }
}

/* NOHZ_FULL 인터랙션 */
/* tick_nohz_cpu_down()은 CPUHP_AP_TICK_NOHZ 상태에서 호출 */
static int tick_nohz_cpu_down(unsigned int cpu)
{
    /* nohz_full CPU가 오프라인되면: */
    /* 1. adaptive-tick 모드 해제 */
    /* 2. 마지막 online housekeeping CPU인지 검사 */
    /* 3. 마지막이면 오프라인 거부 (-EBUSY) */
    if (tick_nohz_cpu_hotpluggable(cpu))
        return 0;
    return -EBUSY;
}

Per-CPU 데이터 처리

Per-CPU 변수 자체는 CPU 오프라인 시 해제되지 않습니다. 메모리는 cpu_possible_mask 기준으로 부팅 시 할당되므로, 오프라인 CPU의 per-CPU 영역도 유지됩니다. 그러나 서브시스템은 자체 콜백에서 per-CPU 데이터를 적절히 정리해야 합니다.

/* 예: perf 서브시스템의 per-CPU 정리 */
static int perf_event_exit_cpu(unsigned int cpu)
{
    struct perf_cpu_context *cpuctx = per_cpu_ptr(&perf_cpu_context, cpu);
    /* 해당 CPU의 모든 perf 이벤트를 다른 CPU로 이동 또는 비활성화 */
    perf_event_exit_cpu_context(cpuctx);
    return 0;
}

스케줄러 통합

CPU Hotplug 시 스케줄러는 sched_domain 계층을 재구성해야 합니다.

/* kernel/sched/topology.c */
static int sched_cpu_deactivate(unsigned int cpu)
{
    /* 1. cpu_active_mask에서 제거 */
    set_cpu_active(cpu, false);

    /* 2. sched_domain 재빌드 요청 */
    cpuset_cpu_inactive(cpu);

    /* 3. 해당 CPU의 실행 가능 태스크 이동 */
    balance_push_set(cpu, true);

    sched_cpu_dying(cpu);
    return 0;
}

static int sched_cpu_activate(unsigned int cpu)
{
    set_cpu_active(cpu, true);
    /* sched_domain 재빌드 → 로드 밸런싱 영역 갱신 */
    cpuset_cpu_active(cpu);
    return 0;
}

전원 관리 연동

CPU Hotplug은 시스템 전원 관리의 핵심 메커니즘입니다.

/* kernel/power/suspend.c — suspend 시 non-boot CPU 오프라인 */
static int suspend_disable_secondary_cpus(void)
{
    int error;
    error = freeze_secondary_cpus(0);  /* CPU 0(BSP) 제외 모두 오프라인 */
    return error;
}

/* resume 시 */
static void suspend_enable_secondary_cpus(void)
{
    thaw_secondary_cpus();  /* 모든 CPU 재온라인 */
}

# 런타임 CPU 격리 (RT 태스크 전용 CPU 확보)
# 방법 1: 부팅 파라미터
isolcpus=2,3 nohz_full=2,3 rcu_nocbs=2,3

# 방법 2: 런타임 hotplug (더 유연)
echo 0 > /sys/devices/system/cpu/cpu2/online
echo 0 > /sys/devices/system/cpu/cpu3/online
taskset -c 2,3 ./rt_workload  # 오프라인이면 실패!

# 방법 3: cpuset cgroup (권장)
echo 2-3 > /sys/fs/cgroup/rt-tasks/cpuset.cpus

가상화 환경

가상 머신에서 vCPU의 동적 추가/제거도 CPU Hotplug 메커니즘을 사용합니다.

# QEMU에서 vCPU 핫플러그 (QMP)
# 1. maxcpus 설정으로 VM 시작 (실제 sockets x cores x threads 조합)
qemu-system-x86_64 -smp 2,maxcpus=4 -cpu host ...

# 2. QMP로 vCPU 추가
{ "execute": "device_add",
  "arguments": { "driver": "host-x86_64-cpu", "socket-id": 0,
                 "core-id": 2, "thread-id": 0, "id": "cpu-2" } }

# 3. 게스트에서 확인
lscpu | grep "CPU(s):"
cat /sys/devices/system/cpu/online

ARM64 특성

ARM64에서 secondary CPU를 깨우는 방법은 두 가지입니다.

/* arch/arm64/kernel/psci.c */
static int cpu_psci_cpu_boot(unsigned int cpu)
{
    phys_addr_t pa = __pa_symbol(secondary_entry);
    int err;

    /* PSCI CPU_ON 호출: 타겟 MPIDR + 진입점 */
    err = psci_ops.cpu_on(cpu_logical_map(cpu), pa);
    return err;
}

static int cpu_psci_cpu_kill(unsigned int cpu)
{
    int err;
    /* CPU 실제 전원 차단을 위해 PSCI AFFINITY_INFO 폴링 */
    do {
        err = psci_ops.affinity_info(cpu_logical_map(cpu), 0);
    } while (err != PSCI_0_2_AFFINITY_LEVEL_OFF);
    return 0;
}

x86 특성

x86에서는 INIT/SIPI(Startup IPI) 시퀀스로 AP(Application Processor)를 시작합니다.

/* arch/x86/kernel/smpboot.c */
static int do_boot_cpu(int apicid, int cpu,
                       struct task_struct *idle)
{
    /* 1. 트램펄린 코드를 1MB 이하 물리 메모리에 복사 */
    /*    (AP는 리얼 모드에서 시작하므로) */
    copy_trampoline_code();

    /* 2. INIT IPI → 100ms 대기 → SIPI 2회 전송 */
    apic_icr_write(APIC_INT_LEVELTRIG | APIC_INT_ASSERT | APIC_DM_INIT,
                   apicid);
    udelay(10000);  /* 10ms */
    apic_icr_write(APIC_DM_INIT, apicid);  /* de-assert */
    udelay(10000);

    /* SIPI: 벡터 주소 = trampoline_base >> 12 */
    apic_icr_write(APIC_DM_STARTUP | (trampoline_phys >> 12), apicid);
    udelay(300);
    /* 두 번째 SIPI (MP Spec 권장) */
    apic_icr_write(APIC_DM_STARTUP | (trampoline_phys >> 12), apicid);

    /* 3. AP가 start_secondary()에 도달할 때까지 대기 */
    wait_for_ap_online(cpu);
    return 0;
}

디버깅

CPU Hotplug 문제를 디버깅하는 주요 도구와 방법입니다.

# cpuhp 상태 머신 전체 상태 확인
cat /sys/devices/system/cpu/hotplug/states

# 특정 CPU의 현재 cpuhp 상태
cat /sys/devices/system/cpu/cpu3/hotplug/state
cat /sys/devices/system/cpu/cpu3/hotplug/target
cat /sys/devices/system/cpu/cpu3/hotplug/fail

# ftrace로 hotplug 이벤트 추적
echo 1 > /sys/kernel/debug/tracing/events/cpuhp/enable
echo 1 > /sys/kernel/debug/tracing/tracing_on
echo 0 > /sys/devices/system/cpu/cpu3/online
cat /sys/kernel/debug/tracing/trace

# trace events: cpuhp_enter, cpuhp_exit, cpuhp_multi_enter
# 출력 예:
# cpuhp_enter: cpu=3 target=206 step=202 (perf/x86:starting)
# cpuhp_exit:  cpu=3 state=202 step=202 ret=0

# stress test (반복 on/off)
for i in $(seq 1 100); do
    echo 0 > /sys/devices/system/cpu/cpu3/online
    echo 1 > /sys/devices/system/cpu/cpu3/online
done

# 커널 로그에서 hotplug 관련 메시지
dmesg | grep -i "cpu.*online\|cpu.*offline\|hotplug\|smpboot"

실전 활용

CPU Hotplug의 대표적인 실전 시나리오와 스크립트입니다.

# 시나리오 1: RT 태스크용 CPU 격리 (hotplug + cset)
# CPU 2,3을 일반 워크로드에서 제외
cset shield --cpu 2-3 --kthread=on
taskset -c 2-3 chrt -f 90 ./rt_application

# 시나리오 2: 에너지 절약 (서버 낮은 부하)
# 현재 부하 기반으로 불필요한 CPU 오프라인
LOAD=$(cat /proc/loadavg | cut -d' ' -f1 | cut -d'.' -f1)
ONLINE=$(nproc)
TARGET=$((LOAD + 2))
if [ "$ONLINE" -gt "$TARGET" ]; then
    for cpu in $(seq $TARGET $((ONLINE-1))); do
        echo 0 > /sys/devices/system/cpu/cpu${cpu}/online 2>/dev/null
    done
fi

# 시나리오 3: MCE 발생 CPU 격리
# /var/log/mcelog에서 에러 CPU 확인 후 격리
echo 0 > /sys/devices/system/cpu/cpu7/online
echo "CPU 7 isolated due to MCE" | logger

동기화 메커니즘

CPU Hotplug 과정에서의 동기화는 percpu rwsem 기반의 cpu_hotplug_lock으로 보호됩니다.

/* include/linux/cpu.h — CPU hotplug 잠금 API */

/* 읽기 잠금: CPU 상태 변경을 차단 (여러 스레드 동시 사용 가능) */
void cpus_read_lock(void);    /* = get_online_cpus() (구식 이름) */
void cpus_read_unlock(void);

/* 쓰기 잠금: CPU 상태 변경 시 (커널 내부 전용) */
void cpus_write_lock(void);
void cpus_write_unlock(void);

/* 사용 예: for_each_online_cpu를 안전하게 사용 */
cpus_read_lock();
for_each_online_cpu(cpu) {
    /* 이 루프 중 CPU가 오프라인되지 않음 보장 */
    per_cpu(my_data, cpu) = compute_value(cpu);
}
cpus_read_unlock();

Workqueue 마이그레이션 전략

Workqueue는 CPU Hotplug에서 특히 복잡한 처리가 필요한 서브시스템입니다. bound workqueue(per-CPU)와 unbound workqueue의 동작이 근본적으로 다르기 때문입니다.

/* kernel/workqueue.c — CPU offline 처리 */
static int workqueue_offline_cpu(unsigned int cpu)
{
    struct worker_pool *pool;

    /* 1. per-CPU bound pool: pending work 드레인 */
    for_each_cpu_worker_pool(pool, cpu) {
        /* 실행 중인 work 완료까지 대기 */
        pool->flags |= POOL_DISASSOCIATED;
        /* worker thread unbind → 다른 CPU에서 실행 가능 */
        unbind_workers(pool);
    }

    /* 2. unbound pool: CPU affinity mask 갱신만 */
    wq_update_unbound_numa(cpu, false);

    return 0;
}

/* kernel/workqueue.c — CPU online 복원 */
static int workqueue_online_cpu(unsigned int cpu)
{
    struct worker_pool *pool;

    /* 1. per-CPU pool 재활성화 */
    for_each_cpu_worker_pool(pool, cpu) {
        pool->flags &= ~POOL_DISASSOCIATED;
        /* 새 worker thread 생성 (필요 시) */
        rebind_workers(pool);
    }

    /* 2. unbound pool NUMA affinity 복원 */
    wq_update_unbound_numa(cpu, true);

    return 0;
}

/* ordered workqueue 생성 예 */
struct workqueue_struct *ordered_wq;
ordered_wq = alloc_ordered_workqueue("my_ordered", 0);
/* max_active = 1, 내부적으로 unbound → CPU hotplug에 안전 */
/* work 실행 순서가 큐잉 순서와 동일하게 보장됨 */

/* per-CPU workqueue에서 flush 후 재큐잉 패턴 */
flush_workqueue(system_wq);
/* CPU 오프라인 후 새 work는 다른 CPU pool에 큐잉됨 */

일반적인 경쟁 조건(Race Condition)과 디버깅

CPU Hotplug은 비동기적으로 CPU 상태를 변경하므로, 다양한 경쟁 조건이 발생할 수 있습니다. 가장 흔한 패턴과 해결 방법을 살펴봅니다.

가장 빈번한 4가지 경쟁 조건 패턴입니다.

/* 패턴 1: cpu_online_mask 경쟁 — 잘못된 코드 */
for_each_online_cpu(cpu) {
    /* ← 이 루프 도중 cpu가 오프라인될 수 있음! */
    per_cpu(my_data, cpu) = do_work(cpu);
}

/* 패턴 1: 올바른 코드 */
cpus_read_lock();
for_each_online_cpu(cpu) {
    per_cpu(my_data, cpu) = do_work(cpu);
}
cpus_read_unlock();

/* 패턴 2: per-cpu 변수 접근 — 잘못된 코드 */
int val = *per_cpu_ptr(&my_counter, target_cpu);
/* target_cpu가 오프라인이면 데이터가 stale/invalid */

/* 패턴 2: 올바른 코드 */
cpus_read_lock();
if (cpu_online(target_cpu)) {
    val = *per_cpu_ptr(&my_counter, target_cpu);
}
cpus_read_unlock();

/* 패턴 3: IRQ affinity 설정 실패 */
ret = irq_set_affinity(irq, cpumask_of(target_cpu));
/* target_cpu가 오프라인이면 -EINVAL 반환 */
/* 해결: cpu_online() 확인 또는 cpus_read_lock() */

/* 패턴 4: hotplug 콜백 내에서 GFP_KERNEL 할당 */
/* Starting 콜백은 IRQ 비활성 상태 → 슬립 불가! */
/* Prepare 콜백에서 메모리를 미리 할당해야 함 */

# ftrace로 hotplug 경쟁 조건 디버깅
echo 1 > /sys/kernel/debug/tracing/events/cpuhp/cpuhp_enter/enable
echo 1 > /sys/kernel/debug/tracing/events/cpuhp/cpuhp_exit/enable
echo 1 > /sys/kernel/debug/tracing/events/cpuhp/cpuhp_multi_enter/enable

# lockdep으로 교착 감지
# CONFIG_PROVE_LOCKING=y 활성화 후
dmesg | grep "possible circular locking"
# cpus_read_lock ↔ mutex ↔ cpus_write_lock 순환 패턴 확인

# hotplug tracepoint 출력 예:
#   cpuhp_enter: cpu=3 target=0 step=202 (perf/x86:starting) ret=0
#   cpuhp_exit:  cpu=3 state=202 step=201 ret=0

Hotplug 성능/지연 분석

CPU online/offline 작업의 소요 시간은 등록된 콜백 수와 각 콜백의 처리 시간에 따라 크게 달라집니다. 대규모 시스템(100+ CPU)에서는 hotplug 지연이 수백 밀리초에 이를 수 있어 성능 분석이 중요합니다.

# 방법 1: ftrace로 각 콜백 소요 시간 측정
echo 1 > /sys/kernel/debug/tracing/events/cpuhp/enable
echo 1 > /sys/kernel/debug/tracing/options/latency-format

echo 0 > /sys/devices/system/cpu/cpu3/online

# trace에서 각 cpuhp_enter ~ cpuhp_exit 시간 차이 분석
cat /sys/kernel/debug/tracing/trace | grep cpuhp
# 출력 예:
#  [001]   125.300: cpuhp_enter: cpu=3 target=0 step=190 (perf:starting)
#  [001]   125.312: cpuhp_exit:  cpu=3 state=190 step=189 ret=0
# → perf:starting 콜백에 12ms 소요

# 방법 2: 직접 시간 측정 스크립트
measure_hotplug() {
    local cpu=$1
    local start end elapsed

    start=$(date +%s%N)
    echo 0 > /sys/devices/system/cpu/cpu${cpu}/online
    end=$(date +%s%N)
    elapsed=$(( (end - start) / 1000000 ))
    echo "CPU${cpu} offline: ${elapsed}ms"

    start=$(date +%s%N)
    echo 1 > /sys/devices/system/cpu/cpu${cpu}/online
    end=$(date +%s%N)
    elapsed=$(( (end - start) / 1000000 ))
    echo "CPU${cpu} online: ${elapsed}ms"
}
# 사용: measure_hotplug 3

Freeze/Thaw 통합 (suspend/hibernate)

시스템 suspend(S3)와 hibernate(S4) 시, 부트 CPU(BSP)를 제외한 모든 CPU가 오프라인됩니다. 이 과정은 일반 CPU hotplug과 동일한 상태 머신을 거치지만, freeze_secondary_cpus()라는 별도 진입점을 사용합니다.

/* kernel/cpu.c — nonboot CPU 일괄 오프라인 */
int freeze_secondary_cpus(int primary)
{
    int cpu, error = 0;

    cpu_maps_update_begin();
    /* 현재 online 마스크 저장 (resume 시 복원용) */
    cpumask_copy(&frozen_cpus, cpu_online_mask);
    cpumask_clear_cpu(primary, &frozen_cpus);

    /* primary(BSP) 제외 모든 CPU 순차 오프라인 */
    for_each_cpu(cpu, &frozen_cpus) {
        error = _cpu_down(cpu, 1, CPUHP_OFFLINE);
        if (error) {
            /* 실패 시: 이미 오프라인한 CPU 롤백 */
            break;
        }
    }
    cpu_maps_update_done();
    return error;
}

/* resume 시 복원 */
void thaw_secondary_cpus(void)
{
    int cpu;

    cpu_maps_update_begin();
    /* 저장된 frozen_cpus 마스크의 CPU를 순차 온라인 */
    for_each_cpu(cpu, &frozen_cpus) {
        _cpu_up(cpu, 1, CPUHP_ONLINE);
    }
    cpu_maps_update_done();
}

freeze_processes()와의 상호작용 — suspend 전체 흐름

1. freeze_processes() — 사용자 프로세스(Process) 동결
2. freeze_kernel_threads() — 커널 스레드(Kernel Thread) 동결
3. suspend_disable_secondary_cpus() — CPU 오프라인
4. syscore_suspend() — 최종 HW 설정
5. (실제 절전 진입)

복원은 역순으로 진행됩니다.

6. syscore_resume()
7. suspend_enable_secondary_cpus() — CPU 온라인
8. thaw_kernel_threads()
9. thaw_processes()

RISC-V CPU Hotplug

RISC-V 아키텍처에서는 SBI(Supervisor Binary Interface)의 HSM(Hart State Management) Extension을 통해 CPU(hart) hotplug을 구현합니다. x86의 INIT/SIPI, ARM64의 PSCI에 대응하는 펌웨어 인터페이스입니다.

/* arch/riscv/kernel/smpboot.c — RISC-V CPU boot */
static int riscv_cpu_start_secondary(
                         struct task_struct *tidle)
{
     unsigned int cpu = tidle->cpu;
     unsigned long hartid = cpuid_to_hartid_map(cpu);
     unsigned long start_addr = __pa_symbol(secondary_start_sbi);

     /* SBI HSM: Hart 시작 요청 (SBI_EXT_HSM_HART_START) */
     struct sbiret ret = sbi_hsm_hart_start(hartid, start_addr, hartid);

     if (ret.error)
         return -EIO;

     /* SBI 펌웨어(OpenSBI 등)가 secondary_start_sbi() 진입점에서 */
     /* hart를 깨움 → smpboot_thread_cpu()를 통해 cpuhp 상태 머신 진행 */
     return 0;
}

/* arch/riscv/kernel/cpu-hotplug.c — RISC-V CPU stop */
void arch_cpu_idle_dead(void)
{
    /* cpuhp 상태 머신이 teardown 완료 후 호출 */
    idle_task_exit();

    /* SBI HSM: 현재 hart 정지 */
    sbi_ecall(SBI_EXT_HSM, SBI_EXT_HSM_HART_STOP,
              0, 0, 0, 0, 0, 0);

    /* 여기에 도달하면 안 됨 — hart는 STOPPED 상태 */
    unreachable();
}

/* SBI HSM 상태 조회 */
static int sbi_hart_get_status(unsigned long hartid)
{
    struct sbiret ret = sbi_ecall(
        SBI_EXT_HSM,
        SBI_EXT_HSM_HART_GET_STATUS,
        hartid, 0, 0, 0, 0, 0);
    return ret.value;
    /* 0: STARTED, 1: STOPPED, 2: START_PENDING, */
    /* 3: STOP_PENDING, 4: SUSPENDED, */
    /* 5: SUSPEND_PENDING, 6: RESUME_PENDING */
}

cpuhp_state 열거형 상세

cpuhp_state 열거형(Enumeration)은 CPU의 bring-up과 tear-down 과정에서 거쳐야 하는 모든 상태를 정의합니다. v7.2 기준 include/linux/cpuhotplug.h에는 이름이 붙은 상태가 179개 정의되어 있고, CPUHP_OFFLINE(값 0)부터 CPUHP_ONLINE(값 236)까지의 번호를 갖습니다. 실제 사용되는 상태 수는 커널 버전과 활성화된 CONFIG 옵션(예: KVM, FTRACE, RCU_NOCB_CPU, NO_HZ_FULL)에 따라 달라집니다. 크게 정적 상태와 동적 상태로 나뉩니다.

/* include/linux/cpuhotplug.h — 상태 열거형 상세 (커널 7.x) */
/* 실제 커널(v7.2)은 이름이 붙은 상태 179개를 가지며, 여기서는 핵심 상태만 추려 순서를 보여줌 */
/* 아래 ... 는 그 외 상태를 생략한 표시이며, 실제 값은 include/linux/cpuhotplug.h 기준 */
enum cpuhp_state {
    CPUHP_INVALID            = -1,
    CPUHP_OFFLINE            = 0,

    /* ====== PREPARE 영역 (제어 CPU에서 실행, IRQ 활성) ====== */
    CPUHP_CREATE_THREADS,           /* smpboot 스레드 생성 */
    CPUHP_PERF_X86_PREPARE,         /* x86 perf 이벤트 준비 */
    CPUHP_SLUB_DEAD,                /* SLUB per-CPU 캐시 정리 */
    CPUHP_PRINTK_DEAD,              /* printk ring buffer 정리 */
    CPUHP_PAGE_ALLOC,               /* per-CPU 페이지 할당자 정리 */
    CPUHP_RANDOM_PREPARE,           /* 난수 풀 준비 */
    CPUHP_WORKQUEUE_PREP,           /* worker pool 준비 */
    CPUHP_POWER_NUMA_PREPARE,       /* NUMA 전원 관리 준비 */
    CPUHP_HRTIMERS_PREPARE,         /* hrtimer 베이스 초기화 */
    CPUHP_X2APIC_PREPARE,           /* x2apic 모드 준비 (x86) */
    CPUHP_SMPCFD_PREPARE,           /* SMP 함수 호출 데이터 할당 */
    CPUHP_RELAY_PREPARE,            /* relay 채널 버퍼 할당 */
    CPUHP_RCUTREE_PREP,             /* RCU 트리 노드 준비 */
    CPUHP_CPUIDLE_COUPLED_PREPARE,  /* coupled cpuidle 준비 */
    CPUHP_TOPOLOGY_PREPARE,         /* 토폴로지 매핑 준비 */
    CPUHP_TIMERS_PREPARE,           /* 타이머 휠 준비 */
    CPUHP_TMIGR_PREPARE,            /* timer migration 준비 */

    /* 동적 PREPARE 슬롯: 모듈용 */
    CPUHP_BP_PREPARE_DYN,           /* 동적 할당 시작점 */
    CPUHP_BP_PREPARE_DYN_END  = CPUHP_BP_PREPARE_DYN + 20,

    CPUHP_BP_KICK_AP,               /* 병렬 bringup 하트비트 */
    CPUHP_BRINGUP_CPU,              /* 아키텍처별 CPU 시작 */

    /* ====== STARTING/DYING 영역 (타겟 CPU, IRQ 비활성) ====== */
    CPUHP_AP_IDLE_DEAD,             /* idle 태스크 정리 */
    CPUHP_AP_OFFLINE,               /* AP 오프라인 마커 */
    CPUHP_AP_SCHED_STARTING,        /* 스케줄러 시작 */
    CPUHP_AP_RCUTREE_DYING,         /* RCU 트리 정리 */
    CPUHP_AP_IRQ_GIC_STARTING,      /* GIC 초기화 (ARM) */
    CPUHP_AP_IRQ_HIP04_STARTING,    /* HiSilicon GIC */
    CPUHP_AP_IRQ_ARMADA_XP_STARTING,/* Marvell MPIC */
    CPUHP_AP_IRQ_BCM2836_STARTING,  /* RPi BCM2836 */
    CPUHP_AP_IRQ_RISCV_SBI_IPI_STARTING, /* RISC-V SBI IPI */
    /* ... (타이머 상태 20여 개, perf 상태 10여 개) ... */
    CPUHP_AP_PERF_X86_STARTING,     /* x86 PMU 초기화 */
    CPUHP_AP_ARM64_DEBUG_MONITORS_STARTING, /* ARM64 디버그 모니터 */
    /* ... (여러 아키텍처 타이머 상태) ... */
    CPUHP_AP_ARM_ARCH_TIMER_STARTING,/* ARM 아키텍처 타이머 */
    /* ... (타이머 상태 다수) ... */
    CPUHP_AP_ARM64_ISNDEP_STARTING, /* ARM64 ISA 비종속 초기화 */
    CPUHP_AP_SMPCFD_DYING,          /* SMP 함수 호출 정리 */
    CPUHP_AP_HRTIMERS_DYING,        /* hrtimer 마이그레이션 */
    CPUHP_AP_TICK_DYING,            /* tick 장치 해제 */

    /* ====== ONLINE 영역 (타겟 CPU, IRQ 활성) ====== */
    CPUHP_AP_ONLINE,                /* 온라인 마커 */
    CPUHP_TEARDOWN_CPU,             /* teardown 완료 후 복귀 */
    CPUHP_AP_ONLINE_IDLE,           /* idle 로직 온라인 */
    CPUHP_AP_KVM_ONLINE,            /* KVM vCPU 온라인 */
    CPUHP_AP_SMPBOOT_THREADS,       /* smpboot 스레드 시작 */
    CPUHP_AP_IRQ_AFFINITY_ONLINE,   /* IRQ affinity 재계산 */
    CPUHP_AP_PERF_ONLINE,           /* perf 이벤트 활성화 */
    CPUHP_AP_WORKQUEUE_ONLINE,      /* workqueue 온라인 */
    CPUHP_AP_RANDOM_ONLINE,         /* 난수 풀 온라인 */
    CPUHP_AP_RCUTREE_ONLINE,        /* RCU 트리 온라인 */
    CPUHP_AP_KTHREADS_ONLINE,       /* kthread 생성 */

    /* 동적 ONLINE 슬롯: 모듈용 */
    CPUHP_AP_ONLINE_DYN,            /* 동적 할당 시작점 */
    CPUHP_AP_ONLINE_DYN_END = CPUHP_AP_ONLINE_DYN + 40,

    CPUHP_AP_ACTIVE,                /* cpu_active_mask 설정 (최종) */
    CPUHP_ONLINE,                   /* 최종 온라인 상태 */
};

# 아래 번호는 include/linux/cpuhotplug.h(v7.2) 기준이며,
# 실제 출력에는 콜백이 등록된 상태만 나타나므로 CONFIG에 따라 달라집니다
cat /sys/devices/system/cpu/hotplug/states
# 출력 예:
#   0: offline
#   1: threads:prepare
#   2: perf:X86:prepare
#   ...  
#  87: sched:starting
#  88: RCU/tree:dying
# 148: smpboot/threads:online
# 189: RCU/tree:online
#   ...  
# 236: online

# 동적 슬롯 사용 현황
cat /sys/devices/system/cpu/hotplug/states | grep "DYN\|dyn"
# 또는 상태 번호 범위로 필터링 (CPUHP_AP_ONLINE_DYN=192 ~ CPUHP_AP_ACTIVE=235)
cat /sys/devices/system/cpu/hotplug/states | awk -F: '{if ($1+0 >= 192 && $1+0 <= 235) print}'

커널 API 상세

CPU Hotplug 콜백을 등록하고 해제하는 API 계열은 여러 변형이 있으며, 각각의 동작 특성을 정확히 이해해야 합니다.

/* include/linux/cpu.h — 핵심 API 시그니처 */

/* 1. 기본 등록: startup/teardown 콜백 + 이미 온라인 CPU에도 호출 */
int cpuhp_setup_state(
    enum cpuhp_state state,   /* 상태 번호 또는 DYN */
    const char *name,          /* 디버그용 이름 */
    int (*startup)(unsigned int cpu),   /* bring-up 콜백 */
    int (*teardown)(unsigned int cpu)   /* tear-down 콜백 */
);
/* 반환: 동적 상태면 할당된 번호 (>0), 정적이면 0, 에러면 <0 */

/* 2. nocalls: 콜백만 등록, 기존 온라인 CPU에 호출 안 함 */
int cpuhp_setup_state_nocalls(
    enum cpuhp_state state,
    const char *name,
    int (*startup)(unsigned int cpu),
    int (*teardown)(unsigned int cpu)
);

/* 3. 멀티 인스턴스: 하나의 콜백에 여러 인스턴스 연결 */
int cpuhp_setup_state_multi(
    enum cpuhp_state state,
    const char *name,
    int (*startup)(unsigned int cpu, struct hlist_node *node),
    int (*teardown)(unsigned int cpu, struct hlist_node *node)
);
/* cpuhp_state_add_instance()로 인스턴스 추가 */
/* cpuhp_state_remove_instance()로 인스턴스 제거 */

/* 4. 해제 */
void cpuhp_remove_state(enum cpuhp_state state);
void cpuhp_remove_state_nocalls(enum cpuhp_state state);
void cpuhp_remove_multi_state(enum cpuhp_state state);

v7.2 기준 API 전체 목록과 호출 규칙

include/linux/cpuhotplug.h에는 위 시그니처 외에도 cpus_read_lock()을 이미 보유한 컨텍스트에서만 호출해야 하는 변형이 다수 존재합니다. 이 변형들은 내부적으로 __cpuhp_setup_state_cpuslocked()를 호출하며, cpuhp_setup_state()가 내부에서 락을 걸어 주는 것과 달리 호출자가 락 보유권을 이미 가지고 있어야 한다는 점이 결정적입니다. 아래 표는 v7.2 헤더의 invoke 인자와 래퍼 구조를 그대로 옮긴 것입니다.

cpuhp_online_idle() — idle 태스크를 통한 온라인 위임

kernel/cpu.c의 cpuhp_online_idle()는 일반적인 Online 콜백과 달리 idle 태스크(idle task)에서 호출되는 진입점입니다. 소스 코드 주석에 명시된 동작은 다음과 같습니다.

/* kernel/cpu.c */
/*
 * Called from the idle task. Wake up the controlling task which brings the
 * hotplug thread of the upcoming CPU up and then delegates the rest of the
 * online bringup to the hotplug thread.
 */
void cpuhp_online_idle(enum cpuhp_state state)
{
    struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state);

    /* 부트 CPU에서는 CPUHP_AP_ONLINE_IDLE 상태가 아니므로 즉시 반환 */
    if (state != CPUHP_AP_ONLINE_IDLE)
        return;

    cpuhp_ap_update_sync_state(SYNC_STATE_ONLINE);

    /* idle 루프 진입 전에 stopper 스레드를 unpark */
    stop_machine_unpark(smp_processor_id());

    st->state = CPUHP_AP_ONLINE_IDLE;
    complete_ap_thread(st, true);
}

콜백 함수(Callback Function) 작성 시 주의사항입니다.

/* 콜백 작성 모범 사례 */

/* Prepare 콜백: 메모리 사전 할당 */
static int my_prepare_cb(unsigned int cpu)
{
    struct my_per_cpu_data *data;

    /* GFP_KERNEL 사용 가능 — 슬립 가능한 컨텍스트 */
    data = kzalloc(sizeof(*data), GFP_KERNEL);
    if (!data)
        return -ENOMEM;

    per_cpu(my_data_ptr, cpu) = data;
    return 0;
}

/* Starting 콜백: HW 초기화 (IRQ 꺼진 상태) */
static int my_starting_cb(unsigned int cpu)
{
    struct my_per_cpu_data *data = per_cpu(my_data_ptr, cpu);

    /* 슬립 불가! spinlock만 사용 */
    /* HW 레지스터 직접 접근 가능 */
    data->hw_reg = readl(data->base + HW_CTRL);
    writel(HW_ENABLE, data->base + HW_CTRL);
    return 0;
}

/* Online 콜백: 서브시스템 알림 */
static int my_online_cb(unsigned int cpu)
{
    struct my_per_cpu_data *data = per_cpu(my_data_ptr, cpu);

    /* IRQ 활성, 슬립 가능 */
    data->worker = kthread_create(my_worker_fn, data,
                                  "my_worker/%d", cpu);
    kthread_bind(data->worker, cpu);
    wake_up_process(data->worker);
    return 0;
}

/* Teardown 콜백: 역순 정리 */
static int my_teardown_cb(unsigned int cpu)
{
    struct my_per_cpu_data *data = per_cpu(my_data_ptr, cpu);

    /* worker 정지 */
    kthread_stop(data->worker);
    /* HW 비활성화 */
    writel(HW_DISABLE, data->base + HW_CTRL);
    /* 메모리 해제 */
    kfree(data);
    per_cpu(my_data_ptr, cpu) = NULL;
    return 0;
}

드라이버 핫플러그(Hotplug) 대응 패턴

디바이스 드라이버(Device Driver)가 CPU Hotplug에 올바르게 대응하려면, per-CPU 자원 관리와 CPU affinity 변경 처리를 체계적으로 구현해야 합니다.

per-CPU 자원 관리 패턴

/* 패턴 1: 정적 per-CPU 변수 + hotplug 콜백 */
static DEFINE_PER_CPU(struct my_stats, cpu_stats);
static enum cpuhp_state hp_state;

static int my_cpu_online(unsigned int cpu)
{
    struct my_stats *stats = per_cpu_ptr(&cpu_stats, cpu);
    memset(stats, 0, sizeof(*stats));
    stats->active = true;
    return 0;
}

static int my_cpu_offline(unsigned int cpu)
{
    struct my_stats *stats = per_cpu_ptr(&cpu_stats, cpu);
    /* 오프라인 CPU의 통계를 CPU 0에 합산 */
    struct my_stats *target = per_cpu_ptr(&cpu_stats, 0);
    target->count += stats->count;
    target->bytes += stats->bytes;
    stats->active = false;
    return 0;
}

/* 패턴 2: 동적 할당 per-CPU 데이터 */
static DEFINE_PER_CPU(struct ring_buffer *, cpu_buffer);

static int my_prepare(unsigned int cpu)
{
    struct ring_buffer *buf;
    /* Prepare 단계에서 메모리 할당 */
    buf = ring_buffer_alloc(BUFFER_SIZE, GFP_KERNEL);
    if (!buf)
        return -ENOMEM;
    per_cpu(cpu_buffer, cpu) = buf;
    return 0;
}

static int my_dead(unsigned int cpu)
{
    struct ring_buffer *buf = per_cpu(cpu_buffer, cpu);
    /* Prepare teardown: 메모리 해제 */
    ring_buffer_free(buf);
    per_cpu(cpu_buffer, cpu) = NULL;
    return 0;
}

CPU Affinity 변경 대응

/* NIC 드라이버의 IRQ affinity 재분배 패턴 */
static int my_nic_cpu_online(unsigned int cpu,
                            struct hlist_node *node)
{
    struct my_nic_priv *priv = hlist_entry_safe(
        node, struct my_nic_priv, cpuhp_node);

    /* 새 CPU가 온라인되면 RX 큐 affinity 재분배 */
    my_nic_rebalance_irq_affinity(priv);
    return 0;
}

static int my_nic_cpu_offline(unsigned int cpu,
                             struct hlist_node *node)
{
    struct my_nic_priv *priv = hlist_entry_safe(
        node, struct my_nic_priv, cpuhp_node);

    /* 오프라인 CPU에 할당된 RX 큐를 다른 CPU로 이동 */
    for (int q = 0; q < priv->num_rx_queues; q++) {
        if (priv->rx_queue[q].cpu == cpu) {
            int new_cpu = cpumask_any_but(cpu_online_mask, cpu);
            priv->rx_queue[q].cpu = new_cpu;
            irq_set_affinity_hint(priv->rx_queue[q].irq,
                                  cpumask_of(new_cpu));
        }
    }
    return 0;
}

/* 프로브 시 멀티 인스턴스 등록 */
static int my_nic_probe(struct pci_dev *pdev, ...)
{
    /* ... */
    ret = cpuhp_state_add_instance(hp_state, &priv->cpuhp_node);
    if (ret)
        goto err;
    /* ... */
}

static void my_nic_remove(struct pci_dev *pdev)
{
    cpuhp_state_remove_instance(hp_state, &priv->cpuhp_node);
    /* ... */
}

NUMA 토폴로지(Topology)와 CPU Hotplug

NUMA(Non-Uniform Memory Access) 시스템에서 CPU Hotplug은 단순한 CPU 제거/추가를 넘어 메모리 접근 지역성(Locality)과 스케줄러 도메인(Domain)에 영향을 미칩니다.

# NUMA 노드별 CPU 확인
lscpu | grep "NUMA"
# NUMA node(s):          2
# NUMA node0 CPU(s):     0-3
# NUMA node1 CPU(s):     4-7

# 또는 sysfs에서 직접 확인
cat /sys/devices/system/node/node0/cpulist  # 0-3
cat /sys/devices/system/node/node1/cpulist  # 4-7

# 특정 NUMA 노드의 CPU 전체 오프라인
for cpu in $(cat /sys/devices/system/node/node1/cpulist | tr ',' '\n' | tr '-' ' ' | while read a b; do seq $a ${b:-$a}; done); do
    [ -f "/sys/devices/system/cpu/cpu${cpu}/online" ] && \
    echo 0 > /sys/devices/system/cpu/cpu${cpu}/online
done

# NUMA 메모리 통계 확인 (CPU 오프라인 전후 비교)
numastat -m
# Node 1의 MemFree/MemUsed는 CPU 오프라인과 무관하게 유지

# 크로스 노드 마이그레이션 확인
cat /proc/vmstat | grep numa_
# numa_hit, numa_miss, numa_foreign 카운터 변화 관찰

NUMA 인식 fallback CPU 선택 — kernel/sched/core.c의 select_fallback_rq() NUMA 우선 로직

1. 같은 NUMA 노드 + affinity mask 내 활성 CPU
2. 다른 NUMA 노드 + affinity mask 내 활성 CPU
3. affinity 무시 + 아무 활성 CPU (최후 수단)

cpuset과의 상호작용

• CPU 오프라인 → cpuset_cpu_inactive() 호출
• cpuset의 effective_cpus에서 해당 CPU 제거
• 자식 cpuset도 재귀적으로 업데이트
• effective_cpus가 비면 부모 cpuset의 CPU를 상속합니다.

cpuset 연동

cpuset cgroup은 프로세스 그룹에 특정 CPU와 메모리 노드를 할당하는 메커니즘으로, CPU Hotplug과 밀접하게 연동됩니다.

# cpuset cgroup v2 설정
# CPU 2,3을 RT 태스크 전용으로 분리
mkdir -p /sys/fs/cgroup/rt-tasks
echo "2-3" > /sys/fs/cgroup/rt-tasks/cpuset.cpus
echo "0" > /sys/fs/cgroup/rt-tasks/cpuset.mems
echo $$ > /sys/fs/cgroup/rt-tasks/cgroup.procs
# 이제 현재 셸과 자식 프로세스는 CPU 2,3에서만 실행

# CPU 2를 오프라인하면?
echo 0 > /sys/devices/system/cpu/cpu2/online
cat /sys/fs/cgroup/rt-tasks/cpuset.cpus.effective
# 출력: 3 (CPU 2가 effective에서 자동 제거됨)

# CPU 2를 다시 온라인하면?
echo 1 > /sys/devices/system/cpu/cpu2/online
cat /sys/fs/cgroup/rt-tasks/cpuset.cpus.effective
# 출력: 2-3 (자동 복원)

/* kernel/cgroup/cpuset.c — CPU hotplug 처리 */
static void cpuset_hotplug_workfn(struct work_struct *work)
{
    /* CPU online/offline 시 호출 */
    /* 1. top_cpuset의 effective_cpus 갱신 */
    cpumask_copy(&top_cpuset.effective_cpus, cpu_active_mask);

    /* 2. 하위 cpuset 재귀 갱신 */
    update_cpumasks_hier(css, &tmp, false);

    /* 3. effective_cpus가 비어진 cpuset 처리 */
    /*    → 부모 cpuset의 effective_cpus 상속 */
    /* 4. 영향받은 태스크의 allowed mask 갱신 */
    rebuild_sched_domains_locked();
}

마이크로코드(Microcode) 적용과 CPU Hotplug

CPU 마이크로코드 업데이트는 CPU Hotplug의 bring-up 과정에서 적용됩니다. 보안 취약점 패치(Patch)나 하드웨어 에라타(Errata) 수정을 위해 런타임에 마이크로코드를 갱신할 수 있으며, hotplug 상태 머신의 Starting 단계에서 처리됩니다.

/* arch/x86/kernel/cpu/microcode/core.c */
/* CPUHP_AP_MICROCODE_STARTING 상태에서 호출 */
static int microcode_bsp_resume(void)
{
    /* suspend/resume 시 BSP 마이크로코드 재적용 */
    return microcode_ops->apply_microcode(smp_processor_id());
}

/* AP (Application Processor) bring-up 시 */
static int mc_cpu_starting(unsigned int cpu)
{
    /* 이미 로드된 마이크로코드를 이 CPU에 적용 */
    microcode_ops->apply_microcode(cpu);
    return 0;
}

/* 등록 */
cpuhp_setup_state_nocalls(CPUHP_AP_MICROCODE_STARTING,
                          "x86/microcode:starting",
                          mc_cpu_starting, NULL);

# 마이크로코드 런타임 업데이트 (late loading)
# 1. 마이크로코드 파일 준비
cp intel-ucode/06-8e-0c /lib/firmware/intel-ucode/

# 2. reload 트리거
echo 1 > /sys/devices/system/cpu/microcode/reload

# 3. 적용 결과 확인
cat /sys/devices/system/cpu/cpu0/microcode/version
# 또는
dmesg | grep microcode
# [12345.678] microcode: updated early: 0x88 → 0x8c

# 4. CPU off/on으로 개별 CPU에 마이크로코드 적용 확인
echo 0 > /sys/devices/system/cpu/cpu3/online
echo 1 > /sys/devices/system/cpu/cpu3/online
cat /sys/devices/system/cpu/cpu3/microcode/version

실전 드라이버 전체 코드

CPU Hotplug 콜백을 올바르게 구현하는 완전한 커널 모듈(Kernel Module) 예제입니다. Prepare + Online 두 단계에 콜백을 등록하고, per-CPU 자원을 안전하게 관리합니다.

/*
 * cpuhp_example.c — CPU Hotplug 콜백 예제 모듈
 *
 * 기능:
 * - per-CPU 통계 버퍼 할당/해제
 * - CPU 온라인 시 worker 스레드 시작
 * - CPU 오프라인 시 통계 합산 및 정리
 * - procfs를 통한 통계 조회
 */
#include <linux/module.h>
#include <linux/cpu.h>
#include <linux/cpuhotplug.h>
#include <linux/percpu.h>
#include <linux/slab.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>

struct cpuhp_example_data {
    u64 events_processed;
    u64 bytes_transferred;
    u32 online_count;   /* 이 CPU가 온라인된 횟수 */
    bool active;
    void *buffer;       /* 작업 버퍼 */
};

#define BUFFER_SIZE  (4096)

static DEFINE_PER_CPU(struct cpuhp_example_data, cpu_data);
static enum cpuhp_state hp_online;  /* 동적 할당된 상태 번호 */
static enum cpuhp_state hp_prepare; /* prepare 상태 번호 */

/* ---- Prepare 콜백: 제어 CPU에서 실행 (슬립 가능) ---- */
static int cpuhp_example_prepare(unsigned int cpu)
{
    struct cpuhp_example_data *data = per_cpu_ptr(&cpu_data, cpu);

    pr_info("cpuhp_example: prepare cpu %u\n", cpu);

    /* 메모리 할당 — GFP_KERNEL 사용 가능 */
    data->buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
    if (!data->buffer)
        return -ENOMEM;

    return 0;
}

/* ---- Prepare teardown: 메모리 해제 ---- */
static int cpuhp_example_dead(unsigned int cpu)
{
    struct cpuhp_example_data *data = per_cpu_ptr(&cpu_data, cpu);

    pr_info("cpuhp_example: dead cpu %u\n", cpu);

    kfree(data->buffer);
    data->buffer = NULL;

    return 0;
}

/* ---- Online 콜백: 타겟 CPU에서 실행 (IRQ 활성) ---- */
static int cpuhp_example_online(unsigned int cpu)
{
    struct cpuhp_example_data *data = this_cpu_ptr(&cpu_data);

    pr_info("cpuhp_example: online cpu %u\n", cpu);

    /* per-CPU 데이터 초기화 */
    data->events_processed = 0;
    data->bytes_transferred = 0;
    data->online_count++;
    data->active = true;

    return 0;
}

/* ---- Online teardown: 통계 합산 후 비활성화 ---- */
static int cpuhp_example_offline(unsigned int cpu)
{
    struct cpuhp_example_data *data = this_cpu_ptr(&cpu_data);
    struct cpuhp_example_data *cpu0_data;

    pr_info("cpuhp_example: offline cpu %u (events=%llu)\n",
            cpu, data->events_processed);

    /* 오프라인 CPU의 통계를 CPU 0에 합산 */
    cpu0_data = per_cpu_ptr(&cpu_data, 0);
    cpu0_data->events_processed += data->events_processed;
    cpu0_data->bytes_transferred += data->bytes_transferred;

    data->active = false;

    return 0;
}

/* ---- procfs: 통계 출력 ---- */
static int cpuhp_example_show(struct seq_file *m, void *v)
{
    int cpu;

    seq_printf(m, "%-6s %-8s %-16s %-16s %-8s\n",
               "CPU", "Active", "Events", "Bytes", "Online#");
    seq_puts(m, "----------------------------------------------\n");

    cpus_read_lock();
    for_each_possible_cpu(cpu) {
        struct cpuhp_example_data *data = per_cpu_ptr(&cpu_data, cpu);
        seq_printf(m, "%-6d %-8s %-16llu %-16llu %-8u\n",
                   cpu,
                   data->active ? "yes" : "no",
                   data->events_processed,
                   data->bytes_transferred,
                   data->online_count);
    }
    cpus_read_unlock();

    return 0;
}

static int cpuhp_example_open(struct inode *inode, struct file *file)
{
    return single_open(file, cpuhp_example_show, NULL);
}

static const struct proc_ops cpuhp_example_ops = {
    .proc_open    = cpuhp_example_open,
    .proc_read    = seq_read,
    .proc_lseek   = seq_lseek,
    .proc_release = single_release,
};

/* ---- 모듈 초기화/종료 ---- */
static int __init cpuhp_example_init(void)
{
    int ret;

    /* 1단계: Prepare 콜백 등록 (메모리 할당) */
    ret = cpuhp_setup_state(CPUHP_BP_PREPARE_DYN,
                            "cpuhp_example:prepare",
                            cpuhp_example_prepare,
                            cpuhp_example_dead);
    if (ret < 0) {
        pr_err("cpuhp_example: prepare state failed: %d\n", ret);
        return ret;
    }
    hp_prepare = ret;

    /* 2단계: Online 콜백 등록 (서비스 시작) */
    ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN,
                            "cpuhp_example:online",
                            cpuhp_example_online,
                            cpuhp_example_offline);
    if (ret < 0) {
        pr_err("cpuhp_example: online state failed: %d\n", ret);
        cpuhp_remove_state(hp_prepare);
        return ret;
    }
    hp_online = ret;

    /* procfs 엔트리 생성 */
    proc_create("cpuhp_example", 0444, NULL, &cpuhp_example_ops);

    pr_info("cpuhp_example: loaded (prepare=%d, online=%d)\n",
            hp_prepare, hp_online);
    return 0;
}

static void __exit cpuhp_example_exit(void)
{
    remove_proc_entry("cpuhp_example", NULL);

    /* Online 콜백 해제 → 온라인 CPU에 teardown 호출 */
    cpuhp_remove_state(hp_online);

    /* Prepare 콜백 해제 → 온라인 CPU에 dead 호출 */
    cpuhp_remove_state(hp_prepare);

    pr_info("cpuhp_example: unloaded\n");
}

module_init(cpuhp_example_init);
module_exit(cpuhp_example_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("CPU Hotplug callback example");
MODULE_AUTHOR("Example");

# 모듈 빌드 (Makefile)
# obj-m := cpuhp_example.o
# make -C /lib/modules/$(uname -r)/build M=$(pwd) modules

# 모듈 로드 및 테스트
insmod cpuhp_example.ko
cat /proc/cpuhp_example
# CPU    Active   Events           Bytes            Online#
# ----------------------------------------------
# 0      yes      0                0                1
# 1      yes      0                0                1
# ...

# CPU off/on 테스트
echo 0 > /sys/devices/system/cpu/cpu3/online
# dmesg: cpuhp_example: offline cpu 3 (events=0)
# dmesg: cpuhp_example: dead cpu 3

echo 1 > /sys/devices/system/cpu/cpu3/online
# dmesg: cpuhp_example: prepare cpu 3
# dmesg: cpuhp_example: online cpu 3

cat /proc/cpuhp_example
# CPU 3의 Online# 카운터가 2로 증가

# 모듈 제거
rmmod cpuhp_example
# dmesg: cpuhp_example: unloaded
# (각 CPU에 offline + dead 콜백 자동 호출)

고급 디버깅 기법

CPU Hotplug 문제는 타이밍에 민감한 경쟁 조건이 많아 재현이 어렵습니다. 체계적인 디버깅 방법론을 소개합니다.

ftrace 활용

# 1. cpuhp 전용 트레이스 설정
cd /sys/kernel/debug/tracing
echo 0 > tracing_on
echo > trace  # 버퍼 초기화

# cpuhp 이벤트 활성화
echo 1 > events/cpuhp/cpuhp_enter/enable
echo 1 > events/cpuhp/cpuhp_exit/enable
echo 1 > events/cpuhp/cpuhp_multi_enter/enable

# 함수 트레이서로 상세 호출 추적
echo function_graph > current_tracer
echo '*cpu_up*' > set_ftrace_filter
echo '*cpu_down*' >> set_ftrace_filter
echo 'cpuhp_*' >> set_ftrace_filter

echo 1 > tracing_on

# CPU off/on 수행
echo 0 > /sys/devices/system/cpu/cpu3/online
echo 1 > /sys/devices/system/cpu/cpu3/online

echo 0 > tracing_on

# 결과 분석
cat trace | head -100
# 각 콜백의 진입/퇴장 시각, 소요 시간, 반환 값 확인

hotplug 실패 강제 주입

# fail 인터페이스로 특정 상태에서 실패 강제
# (CONFIG_CPU_HOTPLUG_STATE_CONTROL=y 필요)
echo 118 > /sys/devices/system/cpu/cpu3/hotplug/fail

# CPU 3 온라인 시도 → 상태 118에서 실패 + 롤백
echo 1 > /sys/devices/system/cpu/cpu3/online
# 실패: -1 반환

# dmesg에서 롤백 과정 확인
dmesg | tail -20
# [xxx] cpuhp/3: Bringing up 3 failed, attempt to roll back

# fail 해제
echo 0 > /sys/devices/system/cpu/cpu3/hotplug/fail

자동화 스트레스 테스트

#!/bin/bash
# cpu_hotplug_stress.sh — CPU hotplug 스트레스 테스트

ITERATIONS=1000
DELAY=0  # 초 (0 = 최대 속도)
LOG="/tmp/cpuhp_stress.log"

# 테스트 대상 CPU (CPU 0 제외)
CPUS=$(cat /sys/devices/system/cpu/online | tr ',' '\n' | tr '-' ' ' | \
       while read a b; do seq $a ${b:-$a}; done | tail -n +2)

echo "Starting stress test: $ITERATIONS iterations" | tee $LOG

fail_count=0
for i in $(seq 1 $ITERATIONS); do
    # 랜덤 CPU 선택
    cpu=$(echo $CPUS | tr ' ' '\n' | shuf -n 1)

    # 현재 상태 확인 후 토글
    state=$(cat /sys/devices/system/cpu/cpu${cpu}/online 2>/dev/null)
    if [ "$state" = "1" ]; then
        echo 0 > /sys/devices/system/cpu/cpu${cpu}/online 2>/dev/null
        result=$?
    else
        echo 1 > /sys/devices/system/cpu/cpu${cpu}/online 2>/dev/null
        result=$?
    fi

    if [ $result -ne 0 ]; then
        echo "[$i] FAIL: cpu$cpu (state=$state)" | tee -a $LOG
        ((fail_count++))
    fi

    [ "$DELAY" != "0" ] && sleep $DELAY
done

# 모든 CPU 복원
for cpu in $CPUS; do
    echo 1 > /sys/devices/system/cpu/cpu${cpu}/online 2>/dev/null
done

echo "Completed: $ITERATIONS iterations, $fail_count failures" | tee -a $LOG
echo "Check dmesg for kernel warnings/errors"

일반적인 문제와 해결

SMT 보안과 CPU Hotplug

하이퍼스레딩(Hyper-Threading, SMT) 관련 하드웨어 취약점(MDS, L1TF, SRBDS 등)에 대응하기 위해 CPU Hotplug으로 SMT sibling을 비활성화하는 것은 중요한 보안 전략입니다.

# SMT 상태 확인
cat /sys/devices/system/cpu/smt/active
# 1 = SMT 활성, 0 = SMT 비활성

cat /sys/devices/system/cpu/smt/control
# on / off / forceoff / notsupported

# SMT 비활성화 (런타임)
echo off > /sys/devices/system/cpu/smt/control
# → 모든 SMT sibling CPU가 자동 오프라인

# 또는 부팅 파라미터
# nosmt — SMT 부팅 시 비활성화
# mitigations=auto,nosmt — 취약점 완화 + SMT 비활성화

# SMT 토폴로지 확인
for cpu in /sys/devices/system/cpu/cpu[0-9]*; do
    [ -f "$cpu/topology/thread_siblings_list" ] && \
    echo "$(basename $cpu): siblings=$(cat $cpu/topology/thread_siblings_list)"
done
# cpu0: siblings=0,4
# cpu1: siblings=1,5
# → CPU 4,5,6,7이 SMT sibling

# 수동으로 SMT sibling만 오프라인
for cpu in /sys/devices/system/cpu/cpu[0-9]*; do
    siblings=$(cat $cpu/topology/thread_siblings_list 2>/dev/null)
    core_id=$(cat $cpu/topology/core_id 2>/dev/null)
    # 각 코어의 두 번째 스레드만 오프라인
    first=$(echo $siblings | cut -d',' -f1)
    num=$(basename $cpu | tr -dc '0-9')
    if [ "$num" != "$first" ] && [ -f "$cpu/online" ]; then
        echo 0 > $cpu/online
    fi
done

/* kernel/cpu.c — SMT control 구현 */
static int cpuhp_smt_disable(enum cpuhp_smt_control ctrlval)
{
    int cpu;

    /* SMT sibling을 모두 오프라인 */
    for_each_online_cpu(cpu) {
        if (topology_smt_supported() &&
            !topology_is_primary_thread(cpu)) {
            /* secondary thread → 오프라인 */
            ret = cpu_down_maps_locked(cpu, CPUHP_OFFLINE);
        }
    }
    cpu_smt_control = ctrlval;
    return 0;
}

/* SMT 비활성 시 CPU 온라인 거부 */
static int cpu_smt_allowed(unsigned int cpu)
{
    if (cpu_smt_control == CPU_SMT_ENABLED)
        return true;
    if (topology_is_primary_thread(cpu))
        return true;
    /* secondary thread는 온라인 거부 */
    return false;
}

커널 설정 옵션 정리

CPU Hotplug 관련 주요 커널 설정(Kernel Configuration) 옵션을 정리합니다.

# 현재 커널의 hotplug 관련 설정 확인
zcat /proc/config.gz 2>/dev/null | grep -E "HOTPLUG|SMP|MICROCODE|RCU_NOCB|NO_HZ_FULL"
# 또는
grep -E "HOTPLUG|SMP|MICROCODE|RCU_NOCB|NO_HZ_FULL" /boot/config-$(uname -r)

# CPU 0 오프라인 가능 여부 확인
if [ -f /sys/devices/system/cpu/cpu0/online ]; then
    echo "CPU 0 hotplug: supported"
else
    echo "CPU 0 hotplug: not supported"
fi

# 부팅 파라미터 확인
cat /proc/cmdline | tr ' ' '\n' | grep -E "maxcpus|possible_cpus|nr_cpus|isolcpus|nohz|rcu_nocbs|nosmt"

부팅 파라미터 참조

CPU Hotplug 동작에 영향을 주는 주요 커널 부팅 파라미터(Boot Parameter)입니다.

# 실전 부팅 파라미터 조합 예시

# RT 워크로드: CPU 0-1 = 시스템, CPU 2-7 = RT 전용
isolcpus=managed_irq,domain,2-7 nohz_full=2-7 rcu_nocbs=2-7

# 가상화: 최대 128 vCPU 지원, 초기 4개만 온라인
maxcpus=4 nr_cpus=128

# 보안: SMT 비활성 + CPU 0 hotplug 활성
nosmt cpu0_hotplug

# 디버깅: hotplug 상태 제어 + CPU 0 테스트
cpu0_hotplug

모범 사례 요약

CPU Hotplug을 안전하고 효율적으로 사용하기 위한 핵심 모범 사례를 정리합니다.

최신 변경사항 (v6.14~v7.2, 2024-2026)

2024년부터 2026년까지 CPU 핫플러그 서브시스템은 RISC-V 병렬 핫플러그(HOTPLUG_PARALLEL), ACPI idle 등록 리팩터, x86/AMD 토폴로지 탐지 정리, arm64 HOTPLUG_PARALLEL 도입 논의 등 핵심 변경을 거쳤습니다. 버전 기준은 2026년 10월 현재 안정판 v7.2이며, 유지 중인 longterm 커널 버전은 v6.18입니다.

RISC-V 병렬 핫플러그 (v6.19)

RISC-V는 SBI(Supervisor Binary Interface) HSM(Hart State Management) 확장을 통해 보조 하트(hart)를 on/off합니다. 여기서 주의할 점은 두 "병렬" 개념이 다르다는 것입니다. 부팅 시 병렬 브링업(parallel boot) 프레임워크는 x86에서 먼저 만들어져 kernel/cpu.c의 공통 코드(CPUHP_BP_KICK_AP, cpuhp_bringup_cpus_parallel())에 구현되어 있고, v6.19 이전의 RISC-V는 이 경로를 사용하지 않았습니다. arch/riscv/kernel/smpboot.c를 버전별로 대조하면 v6.18까지 cpu_running 컴플리션이 무조건 선언되어 wait_for_completion_timeout()로 보조 하트를 하나씩 순차 대기한 반면, v6.19에서 #ifndef CONFIG_HOTPLUG_PARALLEL 가드로 바뀌면서 arch_cpuhp_kick_ap_alive() 구현과 smp_callin()의 cpuhp_ap_sync_alive() 호출이 추가되었습니다. 즉 v6.19의 변경은 새로운 병렬화를 도입한 것이 아니라, 런타임 CPU hotplug(cpu_up()) 경로가 이미 존재하는 공통 병렬 bringup 프레임워크를 RISC-V도 공유하게 된 것입니다.

/* kernel/cpu.c — 아키텍처 공통 병렬 bringup 진입점 (CONFIG_HOTPLUG_PARALLEL) */
/*
 * On architectures which have enabled parallel bringup this invokes all BP
 * prepare states for each of the to be onlined APs first. The last state
 * sends the startup IPI to the APs. The APs proceed through the low level
 * bringup code in parallel and then wait for the control CPU to release
 * them one by one for the final onlining procedure.
 *
 * This avoids waiting for each AP to respond to the startup IPI in
 * CPUHP_BRINGUP_CPU.
 */
static bool cpuhp_bringup_cpus_parallel(unsigned int ncpus)
{
    const struct cpumask *mask = cpu_present_mask;

    if (__cpuhp_parallel_bringup)
        __cpuhp_parallel_bringup = arch_cpuhp_init_parallel_bringup();
    if (!__cpuhp_parallel_bringup)
        return false;

    if (cpuhp_smt_aware()) {
        const struct cpumask *pmask = cpuhp_get_primary_thread_mask();
        static struct cpumask tmp_mask __initdata;

        /*
         * X86 requires to prevent that SMT siblings stopped while
         * the primary thread does a microcode update for various
         * reasons. Bring the primary threads up first.
         */
        cpumask_and(&tmp_mask, mask, pmask);
        cpuhp_bringup_mask(&tmp_mask, ncpus, CPUHP_BP_KICK_AP);
        cpuhp_bringup_mask(&tmp_mask, ncpus, CPUHP_ONLINE);
        ncpus -= num_online_cpus();
        if (!ncpus)
            return true;
        /* Create the mask for secondary CPUs */
        cpumask_andnot(&tmp_mask, mask, pmask);
        mask = &tmp_mask;
    }

    /* Bring the not-yet started CPUs up */
    cpuhp_bringup_mask(mask, ncpus, CPUHP_BP_KICK_AP);
    cpuhp_bringup_mask(mask, ncpus, CPUHP_ONLINE);
    return true;
}

/* 기본값은 true — 아키텍처가 오버라이드하지 않아도 CONFIG가 켜져 있으면 병렬 동작 */
bool __weak arch_cpuhp_init_parallel_bringup(void)
{
    return true;
}

/* arch/riscv/kernel/smpboot.c — RISC-V측 구현 (v6.19에서 추가) */
static int start_secondary_cpu(unsigned int cpu, struct task_struct *tidle)
{
    if (cpu_ops->cpu_start)
        return cpu_ops->cpu_start(cpu, tidle);

    return -EOPNOTSUPP;
}

#ifdef CONFIG_HOTPLUG_PARALLEL */
int arch_cpuhp_kick_ap_alive(unsigned int cpu, struct task_struct *tidle)
{
    return start_secondary_cpu(cpu, tidle);
}
#else
int __cpu_up(unsigned int cpu, struct task_struct *tidle)
{
    int ret;
    tidle->thread_info.cpu = cpu;

    ret = start_secondary_cpu(cpu, tidle);
    if (!ret) {
        wait_for_completion_timeout(&cpu_running, secs_to_jiffies(1));

        if (!cpu_online(cpu)) {
            pr_crit("CPU%u: failed to come online\n", cpu);
            ret = -EIO;
        }
    } else {
        pr_crit("CPU%u: failed to start\n", cpu);
    }

    return ret;
}
#endif

/* 보조 하트 진입점(smp_callin) — 병렬 경로에서는 alive 통지만 수행 */
asmlinkage __visible void smp_callin(void)
{
    /* ... 토폴로지 저장 / IPI 활성화 / NUMA 등록 ... */
#ifdef CONFIG_HOTPLUG_PARALLEL
    cpuhp_ap_sync_alive();
#endif
    /* ... set_cpu_online(), icache/tlb flush ... */
    cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);
}

ARM64 MPAM과 cpuhp

MPAM(Memory Partitioning and Monitoring)은 CPU와 캐시·메모리 컨트롤러가 제공하는 기능으로, 메모리 트래픽에 라벨을 붙이고 분할·모니터링합니다. 커널은 이를 resctrl 사용자 인터페이스로 노출하며, 정책은 resctrl의 schemata 파일로 설정하고 모니터 값은 resctrl로 읽습니다. 드라이버는 drivers/resctrl/mpam_devices.c, mpam_resctrl.c, mpam_internal.h로 구성되며, 사용 가능한 제어 기능은 L2/L3의 캐시 portion bitmap(CPOR), L3 이후 메모리 대역폭(Bandwidth) 상한(MBW_MAX), L3 그룹의 캐시 저장 사용량(CSU) 카운터입니다.

드라이버는 cpuhp 상태를 두 단계에 걸쳐 재등록합니다. mpam_register_cpuhp_callbacks()는 기존 상태를 cpuhp_remove_state()로 해제한 뒤 새 콜백을 등록하고, 등록된 상태 번호는 mpam_cpuhp_state에 캐시되며 mpam_cpuhp_state_lock 뮤텍스(Mutex)로 보호됩니다.

/* drivers/resctrl/mpam_devices.c — 동적 ONLINE 슬롯 등록 */
static int mpam_cpuhp_state;
static DEFINE_MUTEX(mpam_cpuhp_state_lock);

static void mpam_register_cpuhp_callbacks(int (*online)(unsigned int online),
                                  int (*offline)(unsigned int offline),
                                  char *name)
{
    mutex_lock(&mpam_cpuhp_state_lock);
    if (mpam_cpuhp_state) {
        cpuhp_remove_state(mpam_cpuhp_state);
        mpam_cpuhp_state = 0;
    }

    mpam_cpuhp_state = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, name, online,
                     offline);
    if (mpam_cpuhp_state <= 0) {
        pr_err("Failed to register cpuhp callbacks");
        mpam_cpuhp_state = 0;
    }
    mutex_unlock(&mpam_cpuhp_state_lock);
}

/* online 콜백 — CPU가 온라인될 때 해당 CPU가 접근 가능한 MSC를 다시 설정 */
static int mpam_cpu_online(unsigned int cpu)
{
    struct mpam_msc *msc;

    guard(srcu)(&mpam_srcu);
    list_for_each_entry_srcu(msc, &mpam_all_msc, all_msc_list,
                     srcu_read_lock_held(&mpam_srcu)) {
        /* 이 MSC를 접근할 수 있는 CPU인지 확인 */
        if (!cpumask_test_cpu(cpu, &msc->accessibility))
            continue;

        if (msc->reenable_error_ppi)
            _enable_percpu_irq(&msc->reenable_error_ppi);

        /* 첫 번째 온라인 CPU일 때만 하드웨어 재설정 */
        if (atomic_fetch_inc(&msc->online_refs) == 0)
            mpam_reprogram_msc(msc);
    }

    if (mpam_resctrl_enabled)
        return mpam_resctrl_online_cpu(cpu);

    return 0;
}

arm64 HOTPLUG_PARALLEL (2026, 진행 중)

x86과 RISC-V에 이미 들어간 병렬 CPU bringup(HOTPLUG_PARALLEL)을 ARM64에 도입하려는 작업이 2026년 6월부터 진행되고 있습니다. Jinjie Ruan이 제안한 [PATCH RFC] arm64: Add HOTPLUG_PARALLEL support for secondary CPUs 시리즈가 그 시작으로, Will Deacon이 리뷰를 이어가고 있습니다. arch/arm64/kernel/smp.c를 v7.2 기준으로 대조하면 아직 static DECLARE_COMPLETION(cpu_running);과 __cpu_up()의 순차 경로가 남아 있고 CONFIG_HOTPLUG_PARALLEL 분기가 없으므로, v7.2 시점에는 mainline에 병합되지 않은 상태입니다. 따라서 정식 버전 번호는 아직 정해지지 않았습니다.

CONFIG_PARALLEL_SMT_PRIMARY_FIRST (2026)

arm64 병렬 bringup과 함께 SMT(동시 멀티스레딩) 프라이머리 스레드를 먼저 부팅하는 정책 옵션 CONFIG_PARALLEL_SMT_PRIMARY_FIRST(후기 버전에서 CONFIG_HOTPLUG_PARALLEL_SMT로 개명 논의)가 제안되었습니다. SMT sibling을 최대한 늦게 부팅해, 병렬 도메인 초기화 중 캐시·TLB 등 공유 자원 경합(Contention)을 줄이는 것이 목적입니다. x86의 parallel_cpus 재정렬 로직과 동일한 원리입니다.

arm64: secondary CPU의 RCU reporting 지연 (2026)

arm64 병렬 bringup을 위해 secondary CPU가 로컬 CPU 능력(capability) 검사 전까지 RCU quiescent state reporting을 지연하는 변경(arm64: smp: Defer RCU reporting until after local CPU capability checks)도 함께 제안되었습니다. 병렬로 부팅되는 CPU들이 동시에 RCU 상태를 보고하면서 발생할 수 있는 데이터 경합(Race)을 막기 위한 것입니다.

참고자료

커널 공식 문서

• CPU hotplug in the Kernel — cpuhp 상태 머신의 3단 구간, 상태 할당과 콜백 등록/해제 API, 다중 인스턴스(Multi-Instance) 상태 관리. 이 문서가 sysfs 인터페이스와 maxcpus 부팅 매개변수도 함께 다룹니다
• Interaction of Suspend code (S3) with the CPU hotplug infrastructure — 서스펜드 시 CPU 오프라인 처리와 freeze/thaw 연동
• How CPU topology info is exported via sysfs — 온라인/오프라인 CPU 토폴로지 정보의 sysfs 노출 방식
• CPU Isolation — isolcpus, nohz_full, rcu_nocbs로 논리 CPU를 격리하는 커널 측 기법
• MPAM — ARM64 메모리 파티셔닝/모니터링 기능과 resctrl 사용자 인터페이스

LWN.net 기사

• CPU hotplug rework - episode I — Thomas Gleixner가 기존 hotplug 구현의 경쟁 조건을 설명하고 cpuhp 상태 머신을 도입한 경위
• cpu/hotplug: Core infrastructure for cpu hotplug rework — 단계별 콜백 등록 구조로 다시 정리한 2023년 리팩터링의 핵심 인프라
• CPU hotplug: stop_machine()-free CPU hotplug — cpu_up() 경로에서 stop_machine()을 제거하려는 시도
• CPU hotplug: stop_machine()-free CPU hotplug, part 1 — stop_machine() 부재가 cpu_up에 미치는 지연 영향
• Core scheduling — SMT를 끄는 대신 형제 스레드 배치로 동시 실행을 제어하는 접근
• Completing and merging core scheduling — 코어 스케줄링 구현 완성과 커널 병합 과정
• Documentation: core-api/cpuhotplug: Rewrite the API section — cpuhp_setup_state_multi()와 인스턴스 추가/제거 API의 문서화 패치

커널 소스

• kernel/cpu.c — CPU hotplug 코어, cpuhp 상태 머신
• kernel/smpboot.c — SMP 부팅, idle 스레드 생성
• kernel/stop_machine.c — stop_machine 동기화 메커니즘
• include/linux/cpuhotplug.h — cpuhp 상태 enum 정의
• kernel/sched/core.c — 스케줄러 CPU hotplug 콜백
• kernel/rcu/tree.c — RCU CPU hotplug 핸들러(Handler)
• kernel/workqueue.c — Per-CPU worker pool hotplug 처리
• drivers/resctrl/mpam_devices.c — CPUHP_AP_ONLINE_DYN 동적 슬롯을 MPAM용으로 점유하는 실제 드라이버 사례
• arch/riscv/kernel/smpboot.c — CONFIG_HOTPLUG_PARALLEL 기반 RISC-V 병렬 bringup 구현(v6.19 추가)