MSR 레지스터 (Model-Specific Register)

x86 MSR 종합 가이드: RDMSR/WRMSR 명령어, 시스템 제어/SYSCALL/APIC/PMU/전력/보안/가상화 MSR, MTRR/PAT, Linux 커널 MSR API, AMD 전용 MSR, Spectre 완화, KVM MSR 비트맵, msr-tools 디버깅.

MSR 개요

MSR(Model-Specific Register)은 x86 프로세서에 내장된 특수 레지스터 집합으로, CPU의 동작 모드 제어, 성능 모니터링, 전력 관리, 보안 완화 등 다양한 기능을 담당합니다. "Model-Specific"이라는 이름처럼 원래는 CPU 모델마다 다른 레지스터 세트를 가졌으나, 현재는 많은 MSR이 Intel/AMD 간에 공통으로(architectural) 정의되어 있습니다.

MSR의 역사와 발전

• Intel Pentium (1993): RDMSR/WRMSR 명령어 및 TSC(Time Stamp Counter) 최초 도입
• Pentium Pro (P6, 1995): 성능 모니터링 카운터(PMC), MTRR 도입
• AMD K8 (2003): SYSCALL/SYSRET용 MSR, NX bit(IA32_EFER.NXE) 도입
• Intel Core 이후: Architectural Performance Monitoring, SpeedStep/HWP MSR 확대
• Spectre/Meltdown (2018~): IA32_SPEC_CTRL, IA32_PRED_CMD, IA32_ARCH_CAPABILITIES 등 보안 MSR 대거 추가

MSR 주소 공간

MSR은 32비트 주소 공간(0x00000000 ~ 0xFFFFFFFF)을 사용하며, 각 MSR은 64비트(EDX:EAX) 값을 가집니다. 주소 범위는 대략 다음과 같이 구분됩니다:

접근 권한

RDMSR/WRMSR 명령어는 Ring 0(커널 모드)에서만 실행 가능합니다. 유저 공간에서 실행하면 #GP(General Protection) 예외가 발생합니다. 다만 RDTSC, RDTSCP, RDPMC 등 일부 전용 명령어는 CR4 비트 설정에 따라 Ring 3에서도 실행할 수 있습니다.

RDMSR / WRMSR 명령어

명령어 형식

직렬화와 순서 보장

WRMSR은 직렬화(serializing) 명령어로 분류되어, 이전의 모든 명령어가 완료된 후에 실행됩니다. 반면 RDMSR은 직렬화 명령어가 아니므로, 정확한 순서 보장이 필요하면 앞에 LFENCE 또는 MFENCE를 배치해야 합니다.

; 직렬화된 MSR 읽기 패턴
lfence                ; 이전 명령어 완료 보장
mov  $0x10, %ecx    ; IA32_TSC = 0x10
rdmsr                 ; EDX:EAX = TSC 값
shl  $32, %rdx
or   %rax, %rdx      ; RDX = 64비트 TSC

CPUID를 통한 MSR 존재 확인

특정 MSR에 접근하기 전에 해당 기능의 존재 여부를 CPUID로 확인해야 합니다. 존재하지 않는 MSR에 접근하면 #GP(0) 예외가 발생합니다.

시스템 제어 MSR

IA32_EFER (0xC0000080) — Extended Feature Enable Register

Long Mode 활성화와 NX bit 제어를 담당하는 핵심 MSR입니다.

/* arch/x86/kernel/cpu/common.c — Long Mode 진입 시 EFER 설정 */
static void setup_efer(void)
{
    u64 efer;
    rdmsrl(MSR_EFER, efer);

    efer |= EFER_SCE;        /* SYSCALL enable */
    if (boot_cpu_has(X86_FEATURE_NX))
        efer |= EFER_NX;     /* NX bit enable */
    wrmsrl(MSR_EFER, efer);
}

IA32_MISC_ENABLE (0x1A0)

다양한 CPU 기능을 활성화/비활성화하는 범용 제어 레지스터입니다.

IA32_FEATURE_CONTROL (0x3A)

VMX(가상화) 활성화 및 BIOS 잠금을 제어합니다. BIOS/UEFI 펌웨어가 부팅 시 설정하며, Lock bit이 설정되면 재부팅 전까지 변경 불가합니다.

/* arch/x86/kernel/cpu/feat_ctl.c — VMX 활성화 확인 */
void init_ia32_feat_ctl(struct cpuinfo_x86 *c)
{
    u64 msr;

    rdmsrl(MSR_IA32_FEAT_CTL, msr);
    if (msr & FEAT_CTL_LOCKED)
        return;  /* BIOS가 이미 잠금 */

    /* Lock 비트 없이 열려 있으면 직접 설정 */
    msr = FEAT_CTL_LOCKED;
    msr |= FEAT_CTL_VMX_ENABLED_OUTSIDE_SMX;
    wrmsrl(MSR_IA32_FEAT_CTL, msr);
}

SYSCALL / SYSRET MSR

Long Mode에서 SYSCALL/SYSRET 명령어는 시스템 콜 진입/복귀를 위해 3개의 MSR을 사용합니다. 이 MSR들은 IA32_EFER.SCE=1일 때만 유효합니다.

/* arch/x86/kernel/cpu/common.c — SYSCALL MSR 초기화 */
void syscall_init(void)
{
    wrmsr(MSR_STAR, 0,
          (__USER32_CS << 16) | __KERNEL_CS);  /* STAR 상위 32비트 */
    wrmsrl(MSR_LSTAR,
          (unsigned long)entry_SYSCALL_64);   /* 시스템 콜 진입점 */

#ifdef CONFIG_IA32_EMULATION
    wrmsrl(MSR_CSTAR,
          (unsigned long)entry_SYSCALL_compat);
#endif

    /* IF, TF, DF, AC 플래그 마스킹 — 인터럽트/디버그 비활성화 */
    wrmsrl(MSR_SYSCALL_MASK,
          X86_EFLAGS_TF | X86_EFLAGS_DF |
          X86_EFLAGS_IF | X86_EFLAGS_AC);
}

세그먼트 Base MSR (FS/GS)

Long Mode에서 FS/GS 세그먼트의 base 주소는 GDT가 아닌 MSR로 관리됩니다. Linux 커널은 GS_BASE를 per-CPU 데이터 포인터로, FS_BASE를 유저 공간 TLS(Thread-Local Storage)로 사용합니다.

SWAPGS 메커니즘

SWAPGS는 IA32_GS_BASE와 IA32_KERNEL_GS_BASE를 원자적으로 교환합니다. 시스템 콜/인터럽트 진입 시 커널은 SWAPGS를 실행하여 per-CPU 포인터를 GS에 로드하고, 복귀 시 다시 SWAPGS로 유저의 GS를 복원합니다.

; entry_SYSCALL_64 진입부 (arch/x86/entry/entry_64.S)
SYM_CODE_START(entry_SYSCALL_64)
    swapgs                        ; GS = per-CPU base (커널용)
    mov  %rsp, PER_CPU_VAR(cpu_tss_rw + TSS_sp2)
    SWITCH_TO_KERNEL_CR3 scratch_reg=%rsp  ; KPTI: 커널 페이지 테이블 전환
    mov  PER_CPU_VAR(cpu_current_top_of_stack), %rsp
    ; ... 레지스터 저장, 시스템 콜 디스패치

FSGSBASE 명령어 (Linux 5.3+)

FSGSBASE CPU 기능(CPUID.07H:EBX.FSGSBASE[bit 0])이 있으면, RDFSBASE/WRFSBASE/RDGSBASE/WRGSBASE 명령어로 WRMSR 없이 직접 FS/GS base를 읽고 쓸 수 있습니다. 이 명령어들은 비직렬화이며 매우 빠릅니다(~10 사이클 vs WRMSR ~100 사이클).

/* arch/x86/include/asm/fsgsbase.h */
static inline unsigned long rdgsbase(void)
{
    unsigned long gsbase;
    asm volatile("rdgsbase %0" : "=r"(gsbase) :: "memory");
    return gsbase;
}

static inline void wrgsbase(unsigned long gsbase)
{
    asm volatile("wrgsbase %0" :: "r"(gsbase) : "memory");
}

APIC MSR

IA32_APIC_BASE (0x1B)

Local APIC의 기본 주소와 활성화 상태를 제어합니다.

x2APIC 모드 MSR (0x800~0x8FF)

x2APIC 모드에서는 MMIO 대신 MSR을 통해 APIC 레지스터에 접근합니다. 이는 MMIO보다 빠르고 32비트 APIC ID를 지원하여 256 CPU 이상의 시스템을 지원할 수 있습니다.

/* arch/x86/kernel/apic/x2apic_cluster.c — x2APIC IPI 전송 */
static void x2apic_send_IPI(int cpu, int vector)
{
    u32 dest = per_cpu(x86_cpu_to_logical_apicid, cpu);

    /* x2APIC ICR: MSR 0x830, 하위 32비트 = vector+flags, 상위 32비트 = dest */
    wrmsrl(APIC_BASE_MSR + (APIC_ICR >> 4),
          ((u64)dest << 32) | APIC_DM_FIXED | vector);
}

성능 모니터링 MSR (PMU)

Performance Monitoring Unit(PMU) MSR은 CPU 이벤트(캐시 미스, 분기 예측 실패, 명령어 은퇴 등)를 하드웨어 수준에서 카운팅합니다. perf 도구가 내부적으로 이 MSR들을 프로그래밍합니다.

Architectural PMU (버전 2+)

IA32_PERFEVTSELx 비트 필드

비트 63                                                    0
┌────────┬───┬───┬───┬────┬───┬───┬───┬──────────┬──────────┐
│Reserved│INV│CNT│ANY│ EN │INT│ PC│ E │ UnitMask │  Event   │
│ 63:32  │ 23│22 │21 │ 22 │20 │19 │18 │  15:8    │  Select  │
│        │   │MASK    │    │   │   │   │  (umask) │   7:0    │
└────────┴───┴───┴───┴────┴───┴───┴───┴──────────┴──────────┘

EN (bit 22)  = 카운터 활성화
INT (bit 20) = 오버플로 시 PMI 인터럽트 발생
USR (bit 16) = Ring 3 이벤트 카운팅
OS  (bit 17) = Ring 0 이벤트 카운팅

/* L3 캐시 미스 이벤트 프로그래밍 예 */
#define PERFEVTSEL_EN      (1ULL << 22)
#define PERFEVTSEL_OS      (1ULL << 17)
#define PERFEVTSEL_USR     (1ULL << 16)

/* Event 0x2E, Umask 0x41 = LLC-misses (Skylake 기준) */
u64 evtsel = 0x2E | (0x41 << 8) |
            PERFEVTSEL_EN | PERFEVTSEL_OS | PERFEVTSEL_USR;
wrmsrl(MSR_P6_EVNTSEL0, evtsel);

/* 카운터 읽기 */
u64 count;
rdmsrl(MSR_P6_PERFCTR0, count);
pr_info("LLC misses: %llu\n", count);

전력/주파수 MSR

현대 x86 CPU는 MSR을 통해 동적 주파수/전압 조절(DVFS)을 제어합니다. Linux의 cpufreq 드라이버(intel_pstate, amd-pstate)가 이 MSR들을 직접 사용하여 CPU의 성능 수준을 조절합니다. 이 섹션에서는 P-State 제어, HWP(Hardware P-States), RAPL(전력 제한), C-State 레지던시, AMD CPPC 등 전력/주파수 관련 MSR 전체를 상세히 다룹니다.

MSR_PLATFORM_INFO (0xCE) — 플랫폼 주파수 정보

CPU의 기본 주파수 비율(ratio), 최소/최대 비율, TDP 관련 정보를 담고 있는 읽기 전용 MSR입니다. intel_pstate 드라이버가 초기화 시 가장 먼저 읽는 MSR입니다.

/* drivers/cpufreq/intel_pstate.c — 플랫폼 정보에서 주파수 범위 결정 */
static void intel_pstate_get_cpu_pstates(struct cpudata *cpu)
{
    u64 value;

    rdmsrl(MSR_PLATFORM_INFO, value);

    /* Base Frequency ratio (bits 15:8) */
    cpu->pstate.max_pstate = (value >> 8) & 0xFF;
    /* Minimum Efficiency ratio (bits 40:32) */
    cpu->pstate.min_pstate = (value >> 32) & 0xFF;
    /* 예: max_pstate=34 → 3.4GHz, min_pstate=4 → 400MHz (BCLK=100MHz) */

    rdmsrl(MSR_TURBO_RATIO_LIMIT, value);
    cpu->pstate.turbo_pstate = value & 0xFF;  /* 1코어 활성 시 최대 터보 비율 */

    pr_debug("cpu %d: min=%d base=%d turbo=%d\n",
             cpu->cpu, cpu->pstate.min_pstate,
             cpu->pstate.max_pstate, cpu->pstate.turbo_pstate);
}

IA32_PERF_CTL / IA32_PERF_STATUS — P-State 제어 (레거시 EIST)

Enhanced Intel SpeedStep Technology(EIST)에서 OS가 직접 목표 P-State를 설정하고, 현재 P-State를 읽는 데 사용하는 MSR 쌍입니다. HWP 활성화 시에도 레거시 호환을 위해 존재하지만, 실질적 제어는 HWP MSR이 담당합니다.

IA32_PERF_CTL (0x199) — 목표 P-State 설정

IA32_PERF_STATUS (0x198) — 현재 P-State (읽기 전용)

/* 레거시 P-State 전환 — acpi-cpufreq 드라이버 */
/* drivers/cpufreq/acpi-cpufreq.c */
static void do_drv_write(void *_cmd)
{
    struct drv_cmd *cmd = _cmd;

    /* MSR_IA32_PERF_CTL에 목표 비율 쓰기 */
    wrmsrl(MSR_IA32_PERF_CTL,
           cmd->val | (rdmsrl(MSR_IA32_PERF_CTL) & ~0xFFFFULL));
    /*
     * P-State 전환은 즉각적이지 않음:
     * - Intel: ~10μs (전압/주파수 안정화)
     * - 전환 중 IA32_PERF_STATUS 값이 점진적으로 변경
     * - IA32_MISC_ENABLE[16] (EIST Enable)이 1이어야 동작
     */
}

MSR_TURBO_RATIO_LIMIT (0x1AD) — 터보 부스트 비율 제한

활성 코어 수에 따른 최대 터보 부스트 비율을 정의합니다. 활성 코어가 적을수록 더 높은 주파수까지 부스트할 수 있습니다 (열/전력 여유분 활용).

/* 터보 비율 파싱 — turbostat 도구 로직과 유사 */
static void dump_turbo_ratios(void)
{
    u64 turbo_limit;
    int i;

    rdmsrl(MSR_TURBO_RATIO_LIMIT, turbo_limit);
    for (i = 0; i < 8; i++) {
        u8 ratio = (turbo_limit >> (i * 8)) & 0xFF;
        pr_info("%dC turbo: %d (%d MHz)\n",
               i + 1, ratio, ratio * 100);
    }
    /*
     * 출력 예시 (i7-12700):
     * 1C turbo: 49 (4900 MHz)   ← 단일 코어 최대
     * 2C turbo: 49 (4900 MHz)
     * 3C turbo: 48 (4800 MHz)
     * 4C turbo: 47 (4700 MHz)
     * ...
     * 8C turbo: 46 (4600 MHz)   ← 전코어 터보
     */
}

/* 코어 수가 8 이상인 CPU는 추가 MSR 사용:
 * MSR_TURBO_RATIO_LIMIT1 (0x1AE): 코어 9~16
 * MSR_TURBO_RATIO_LIMIT2 (0x1AF): 코어 17~24
 * MSR_TURBO_RATIO_LIMIT3 (0x1AC): 그룹별 비율 (Atom 계열)
 */

HWP (Hardware P-States) — Intel Speed Shift 심화

HWP는 Skylake(6세대) 이후 Intel CPU에서 지원하는 하드웨어 자율 P-State 관리 기술입니다. 기존 EIST에서는 OS가 매번 목표 P-State를 결정해야 했으나, HWP에서는 OS가 성능 범위와 선호도만 설정하면 CPU 하드웨어가 부하, 온도, 전력 상태를 종합적으로 판단하여 최적의 P-State를 자율 선택합니다. P-State 전환 응답 시간이 ~10ms에서 ~30μs로 대폭 개선됩니다.

IA32_PM_ENABLE (0x770) — HWP 활성화

IA32_HWP_CAPABILITIES (0x771) — 하드웨어 성능 범위 (읽기 전용)

CPU가 보고하는 P-State 범위. OS는 이 범위 내에서 HWP_REQUEST를 설정해야 합니다.

/* IA32_HWP_CAPABILITIES 파싱 */
static void read_hwp_caps(struct cpudata *cpu)
{
    u64 cap;
    rdmsrl(MSR_IA32_HWP_CAPABILITIES, cap);

    cpu->hwp_cap.highest  = HWP_HIGHEST_PERF(cap);      /* bits 7:0   */
    cpu->hwp_cap.guaranteed = HWP_GUARANTEED_PERF(cap);  /* bits 15:8  */
    cpu->hwp_cap.efficient = HWP_MOSTEFFICIENT_PERF(cap); /* bits 23:16 */
    cpu->hwp_cap.lowest   = HWP_LOWEST_PERF(cap);       /* bits 31:24 */

    /*
     * 실제 예시 (Intel i9-13900K):
     *   Highest=49, Guaranteed=34, Efficient=8, Lowest=4
     *   → 4.9GHz 최대, 3.4GHz 보장, 800MHz 효율, 400MHz 최저
     */
}

IA32_HWP_REQUEST (0x774) — OS → HW 성능 요청 (코어별)

OS가 HWP에 전달하는 성능 힌트. 각 논리 코어별로 독립 설정 가능합니다.

EPP (Energy Performance Preference) 상세

EPP는 HWP에서 성능과 에너지 효율 사이의 균형점을 OS가 CPU에 전달하는 핵심 파라미터입니다. 값이 작을수록 성능 우선, 클수록 절전 우선입니다.

/* drivers/cpufreq/intel_pstate.c — HWP_REQUEST 설정 (전체 필드) */
static void intel_pstate_hwp_set(struct cpudata *cpu)
{
    u64 value, prev;
    s16 epp;

    rdmsrl_on_cpu(cpu->cpu, MSR_IA32_HWP_REQUEST, &prev);

    value  = HWP_MIN_PERF(cpu->pstate.min_pstate);      /* bits 7:0   */
    value |= HWP_MAX_PERF(cpu->pstate.max_pstate);      /* bits 15:8  */
    value |= HWP_DESIRED_PERF(0);                       /* bits 23:16 — 0 = 자율 모드 */
    epp = intel_pstate_get_epp(cpu);
    value |= HWP_ENERGY_PERF_PREFERENCE(epp);            /* bits 31:24 */

    if (value != prev) {
        wrmsrl_on_cpu(cpu->cpu, MSR_IA32_HWP_REQUEST, value);
        trace_cpu_frequency(cpu->pstate.max_pstate * cpu->pstate.scaling, cpu->cpu);
    }
}

IA32_HWP_REQUEST_PKG (0x772) — 패키지 레벨 HWP 요청

패키지(소켓) 전체에 대한 HWP 요청을 설정합니다. 코어별 HWP_REQUEST에서 Package_Control 비트(42)가 0인 경우 이 MSR의 값이 기본 적용됩니다.

IA32_HWP_INTERRUPT (0x773) — HWP 변경 알림 인터럽트

IA32_HWP_STATUS (0x777) — HWP 상태 피드백

/* HWP 인터럽트 핸들러 — 보장 성능 변경 처리 */
void intel_pstate_irq_handler(void)
{
    u64 status;
    rdmsrl(MSR_IA32_HWP_STATUS, status);

    if (status & 0x1) {
        /* Guaranteed Performance 변경 — 열 스로틀링 등으로 발생 */
        u64 cap;
        rdmsrl(MSR_IA32_HWP_CAPABILITIES, cap);
        pr_info("HWP guaranteed perf changed to %llu\n",
               (cap >> 8) & 0xFF);
        /* 상태 비트 클리어 (W1C) */
        wrmsrl(MSR_IA32_HWP_STATUS, status);
    }
}

APERF / MPERF — 실제 주파수 측정

APERF와 MPERF는 CPU의 실제 동작 주파수와 활용률을 측정하는 핵심 카운터 쌍입니다. 두 카운터 모두 C0 상태(활성)에서만 증가하며, C-State(유휴)에서는 멈춥니다.

APERF/MPERF를 이용한 핵심 계산

/*
 * 두 시점(t0, t1) 사이의 델타를 이용한 계산:
 *
 * 1) 실제 평균 주파수:
 *    actual_freq = base_freq × (ΔAPERF / ΔMPERF)
 *    - ΔAPERF > ΔMPERF → 터보 부스트 활성 (base_freq 초과)
 *    - ΔAPERF < ΔMPERF → 스로틀링 발생 (base_freq 미만)
 *    - ΔAPERF = ΔMPERF → 정확히 base_freq로 동작
 *
 * 2) C0 레지던시 (CPU 활용률):
 *    busy% = ΔMPERF / ΔTSC × 100
 *    - TSC는 항상 일정 비율로 증가 (invariant TSC)
 *    - MPERF는 C0에서만 증가
 *    → ΔMPERF/ΔTSC = C0 상태에서 보낸 시간 비율
 *
 * 3) 평균 주파수 (유휴 포함):
 *    avg_freq = TSC_freq × (ΔAPERF / ΔTSC)
 *    - 전체 시간 대비 실제 작업량 반영
 */

struct freq_sample {
    u64 aperf, mperf, tsc;
};

static void snapshot(struct freq_sample *s)
{
    unsigned long flags;
    local_irq_save(flags);
    rdmsrl(MSR_IA32_APERF, s->aperf);
    rdmsrl(MSR_IA32_MPERF, s->mperf);
    s->tsc = rdtsc_ordered();
    local_irq_restore(flags);
}

static void calc_freq(struct freq_sample *s0, struct freq_sample *s1)
{
    u64 da = s1->aperf - s0->aperf;
    u64 dm = s1->mperf - s0->mperf;
    u64 dt = s1->tsc   - s0->tsc;
    u64 base_khz = tsc_khz;  /* 커널 전역 변수 */

    pr_info("actual_freq = %llu MHz\n",
           div64_u64(base_khz * da, dm) / 1000);
    pr_info("C0 busy = %llu.%llu%%\n",
           dm * 100 / dt, (dm * 10000 / dt) % 100);
    pr_info("avg_freq (incl idle) = %llu MHz\n",
           div64_u64(base_khz * da, dt) / 1000);
}

RAPL (Running Average Power Limit) MSR

RAPL은 Intel Sandy Bridge 이후 도입된 전력 측정 및 제한 메커니즘으로, 패키지/코어/DRAM/GPU의 실시간 전력 소비를 모니터링하고, 전력 상한을 설정할 수 있습니다. 커널의 intel_rapl 드라이버와 powercap 프레임워크가 이 MSR들을 추상화합니다.

RAPL 도메인 (Power Domain)

MSR_RAPL_POWER_UNIT (0x606) — 전력 단위

RAPL MSR의 값을 물리 단위로 변환하기 위한 단위 정보입니다. 모든 RAPL 값 해석의 기준이 됩니다.

/* RAPL 단위 파싱 */
static void parse_rapl_units(void)
{
    u64 units;
    double power_unit, energy_unit, time_unit;

    rdmsrl(MSR_RAPL_POWER_UNIT, units);

    power_unit  = 1.0 / (1 << (units & 0xF));         /* 보통 0.125W  */
    energy_unit = 1.0 / (1 << ((units >> 8) & 0x1F));  /* 보통 ~61μJ   */
    time_unit   = 1.0 / (1 << ((units >> 16) & 0xF)); /* 보통 ~976μs  */

    /* 예: Power Unit=3 → 1/8=0.125W
     *     Energy Unit=14 → 1/16384 ≈ 61.04μJ
     *     Time Unit=10 → 1/1024 ≈ 976.6μs
     */
}

MSR_PKG_POWER_LIMIT (0x610) — 패키지 전력 제한

패키지 레벨의 전력 제한(PL1/PL2)을 설정합니다. PL1은 장기(sustained) TDP, PL2는 단기(burst) TDP입니다.

/* drivers/powercap/intel_rapl_msr.c — RAPL 전력 제한 설정 */
static int set_domain_power_limit(struct rapl_domain *rd,
                                  u64 power_limit_uw, int pl_id)
{
    u64 val, mask;
    int shift = (pl_id == 1) ? 0 : 32;

    rdmsrl(rd->msr_power_limit, val);

    /* 와트를 RAPL 단위로 변환 */
    u64 raw = div64_u64(power_limit_uw,
                        rd->rp->power_unit * 1000000ULL);
    mask = 0x7FFFULL << shift;
    val = (val & ~mask) | ((raw & 0x7FFF) << shift);
    val |= (1ULL << (15 + shift));  /* Enable bit */

    wrmsrl(rd->msr_power_limit, val);
    return 0;
}

MSR_PKG_ENERGY_STATUS (0x611) — 패키지 에너지 소비 (읽기 전용)

패키지의 누적 에너지 소비량입니다. 32비트 카운터로, 오버플로우됩니다.

/* 패키지 전력 측정 (두 시점 간 에너지 차이) */
static u64 measure_pkg_power_mw(unsigned int interval_ms)
{
    u64 e0, e1, units;
    u64 energy_unit;

    rdmsrl(MSR_RAPL_POWER_UNIT, units);
    energy_unit = 1000000ULL >> ((units >> 8) & 0x1F);  /* μJ 단위 */

    rdmsrl(MSR_PKG_ENERGY_STATUS, e0);
    msleep(interval_ms);
    rdmsrl(MSR_PKG_ENERGY_STATUS, e1);

    /* 32비트 오버플로우 처리 */
    u64 delta = (e1 - e0) & 0xFFFFFFFF;
    /* mW = (delta × energy_unit_μJ) / interval_ms */
    return div64_u64(delta * energy_unit, interval_ms);
}
/*
 * 오버플로우 주기 예시:
 *   Energy Unit=14 → 61μJ/count
 *   200W 소비 시: 2^32 × 61μJ / 200W ≈ 1311초 ≈ ~22분
 *   커널은 주기적으로 읽어 오버플로우를 추적해야 함
 */

RAPL 도메인별 MSR 주소 정리

C-State 관련 MSR

C-State MSR은 CPU 유휴 상태 제어와 각 C-State의 레지던시(체류 시간) 측정에 사용됩니다. cpuidle 드라이버(intel_idle)와 turbostat이 이 MSR들을 활용합니다.

MSR_PKG_CST_CONFIG_CONTROL (0xE2) — 패키지 C-State 제어

C-State 레지던시 MSR (코어/패키지)

/* C-State 레지던시 비율 측정 */
static void measure_cstate_residency(unsigned int interval_ms)
{
    u64 tsc0, tsc1, c6_0, c6_1, c7_0, c7_1;

    tsc0 = rdtsc_ordered();
    rdmsrl(MSR_CORE_C6_RESIDENCY, c6_0);
    rdmsrl(MSR_CORE_C7_RESIDENCY, c7_0);

    msleep(interval_ms);

    tsc1 = rdtsc_ordered();
    rdmsrl(MSR_CORE_C6_RESIDENCY, c6_1);
    rdmsrl(MSR_CORE_C7_RESIDENCY, c7_1);

    u64 dt  = tsc1 - tsc0;
    u64 dc6 = c6_1 - c6_0;
    u64 dc7 = c7_1 - c7_0;

    pr_info("C6 residency: %llu.%02llu%%\n",
           dc6 * 100 / dt, (dc6 * 10000 / dt) % 100);
    pr_info("C7 residency: %llu.%02llu%%\n",
           dc7 * 100 / dt, (dc7 * 10000 / dt) % 100);
    /*
     * turbostat 출력과 대응:
     *   CPU%c1 = C1 residency %, CPU%c6 = C6 residency %
     *   Pkg%pc2 = Package C2 %, Pkg%pc6 = Package C6 %
     *   이상적인 유휴 서버: Pkg%pc6 > 90%
     */
}

IA32_ENERGY_PERF_BIAS (0x1B0) — 에너지 성능 편향

HWP의 EPP보다 이전에 도입된(Sandy Bridge+) 레거시 에너지 성능 힌트입니다. HWP가 활성화되지 않은 시스템에서 CPU의 자율적 전력 관리 결정에 힌트를 제공합니다.

IA32_CLOCK_MODULATION (0x19A) — 클럭 변조 (레거시 스로틀링)

소프트웨어 제어 클럭 변조(Software Controlled Clock Modulation, aka duty cycling)를 설정합니다. 이는 가장 초기의 전력 관리 기법으로, CPU 클럭을 일정 비율로 on/off 하여 전력을 줄입니다. 현대 CPU에서는 DVFS가 훨씬 효율적이므로 거의 사용되지 않습니다.

AMD P-State MSR (CPPC)

AMD Zen 아키텍처 CPU는 ACPI CPPC(Collaborative Processor Performance Control) 프레임워크를 기반으로 P-State를 관리합니다. Linux의 amd-pstate 드라이버(5.17+)가 이 MSR들을 사용합니다.

MSR_AMD_CPPC_ENABLE (0xC00102B1) — CPPC 활성화

MSR_AMD_CPPC_CAP1 (0xC00102B0) — CPPC 성능 범위

MSR_AMD_CPPC_REQ (0xC00102B3) — CPPC 성능 요청

MSR_AMD_PSTATE_DEF (0xC0010064 ~ 0xC0010069) — P-State 정의

AMD CPU는 최대 8개의 하드웨어 P-State 정의를 MSR에 보관합니다 (P0~P7). 각 MSR은 FID(주파수), DID(분주비), VID(전압)를 인코딩합니다.

/* AMD P-State 주파수 계산 */
static u32 amd_pstate_freq_mhz(u64 pstate_def)
{
    u32 fid = pstate_def & 0xFF;
    u32 did = (pstate_def >> 8) & 0x3F;

    if (did == 0)
        return 0;  /* 0으로 나눗셈 방지 */
    /* Frequency (MHz) = 200 × FID / DID */
    return 200 * fid / did;
    /*
     * 예: Ryzen 9 7950X P0
     *   FID=0xB0 (176), DID=0x08 (8)
     *   Freq = 200 × 176 / 8 = 4400 MHz
     */
}

/* drivers/cpufreq/amd-pstate.c — CPPC 성능 요청 */
static void amd_pstate_update(struct amd_cpudata *cpudata,
                              u32 min_perf, u32 des_perf,
                              u32 max_perf, bool fast_switch)
{
    u64 value = READ_ONCE(cpudata->cppc_req_cached);

    value &= ~(AMD_CPPC_MIN_PERF_MASK | AMD_CPPC_DES_PERF_MASK |
               AMD_CPPC_MAX_PERF_MASK);
    value |= AMD_CPPC_MIN_PERF(min_perf);
    value |= AMD_CPPC_DES_PERF(des_perf);
    value |= AMD_CPPC_MAX_PERF(max_perf);

    if (fast_switch)
        wrmsrl(MSR_AMD_CPPC_REQ, value);
    else
        wrmsrl_on_cpu(cpudata->cpu, MSR_AMD_CPPC_REQ, value);
}

cpufreq 드라이버와 MSR 매핑

Linux 커널의 cpufreq 프레임워크는 MSR을 직접 노출하지 않고, sysfs를 통해 추상화합니다. 각 sysfs 파일이 어떤 MSR을 읽고 쓰는지 이해하면 디버깅에 유용합니다.

# 전력/주파수 관련 주요 확인 명령어

# 현재 주파수 정책 확인
cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_driver      # intel_pstate 또는 amd-pstate
cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor     # performance, powersave 등

# HWP/EPP 확인 (Intel)
cat /sys/devices/system/cpu/cpu0/cpufreq/energy_performance_preference
cat /sys/devices/system/cpu/cpu0/cpufreq/energy_performance_available_preferences

# RAPL 전력 확인
cat /sys/class/powercap/intel-rapl:0/name                     # package-0
cat /sys/class/powercap/intel-rapl:0/energy_uj                # 누적 에너지 (μJ)
cat /sys/class/powercap/intel-rapl:0/constraint_0_power_limit_uw  # PL1 (μW)

# turbostat으로 종합 확인
turbostat --show Core,CPU,Avg_MHz,Busy%,Bzy_MHz,TSC_MHz,PkgWatt,CorWatt,Pkg%pc2,Pkg%pc6

# MSR 직접 읽기 (msr-tools)
rdmsr -p 0 0xCE                # MSR_PLATFORM_INFO
rdmsr -p 0 0x1AD               # MSR_TURBO_RATIO_LIMIT
rdmsr -p 0 0x774 -f 31:24      # HWP_REQUEST의 EPP 필드만
rdmsr -p 0 0x611               # PKG_ENERGY_STATUS (RAPL)

열 관리 MSR

CPU 온도 모니터링과 열 스로틀링(thermal throttling) 제어를 위한 MSR입니다.

온도 계산 방법

Intel CPU는 TjMax로부터의 거리(Digital Readout)를 보고합니다:

/* drivers/hwmon/coretemp.c — 코어 온도 읽기 */
static int get_core_temp(int cpu)
{
    u32 eax, edx;
    int tjmax, temp;

    /* TjMax 읽기 (보통 100°C) */
    rdmsr_on_cpu(cpu, MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
    tjmax = (eax >> 16) & 0xFF;

    /* 현재 온도 = TjMax - Digital Readout */
    rdmsr_on_cpu(cpu, MSR_IA32_THERM_STATUS, &eax, &edx);
    if (eax & 0x80000000) {  /* Reading Valid 비트 */
        temp = tjmax - ((eax >> 16) & 0x7F);
        return temp;  /* 섭씨 온도 */
    }
    return -1;
}

TSC 관련 MSR

TSC(Time Stamp Counter)는 가장 자주 사용되는 MSR 중 하나로, 고해상도 시간 측정의 기반입니다.

TSC-Deadline 모드

TSC-Deadline 모드는 APIC 타이머의 최신 모드로, 지정한 TSC 값에 도달하면 인터럽트를 발생시킵니다. 기존 one-shot/periodic 모드보다 정밀합니다.

/* arch/x86/kernel/apic/apic.c — TSC-Deadline 타이머 설정 */
static void setup_APIC_tsc_deadline(u64 deadline)
{
    /* LVT Timer에 TSC-Deadline 모드 설정 */
    apic_write(APIC_LVTT, APIC_LVT_TIMER_TSCDEADLINE | LOCAL_TIMER_VECTOR);
    /* 목표 TSC 값 쓰기 — 이 값에 도달하면 인터럽트 */
    wrmsrl(MSR_IA32_TSC_DEADLINE, deadline);
}

TSC_ADJUST — 가상화 환경 TSC 동기화

KVM은 vCPU 마이그레이션 시 IA32_TSC_ADJUST를 사용하여 게스트가 인식하는 TSC 값을 보정합니다. 게스트가 보는 TSC = 물리 TSC + TSC_OFFSET + TSC_ADJUST입니다.

보안 MSR (Spectre/Meltdown 완화)

2018년 Spectre/Meltdown 취약점 발견 이후, CPU 벤더들은 소프트웨어 기반 완화를 지원하기 위한 MSR을 대거 추가했습니다.

IA32_ARCH_CAPABILITIES (0x10A)

CPU가 특정 취약점에 하드웨어적으로 면역인지 보고합니다(읽기 전용). 커널은 이 MSR을 읽어 불필요한 완화를 건너뜁니다.

추론 실행 제어 MSR

각 완화 기법의 동작

/* arch/x86/kernel/cpu/bugs.c — Spectre v2 완화 */

/* IBRS: 간접 분기가 하위 권한 예측을 사용하지 않음 */
static void spec_ctrl_enable_ibrs(void)
{
    u64 msr = this_cpu_read(x86_spec_ctrl_current);
    msr |= SPEC_CTRL_IBRS;
    native_wrmsrl(MSR_IA32_SPEC_CTRL, msr);
}

/* IBPB: 분기 예측기 전체 무효화 (컨텍스트 스위치 시) */
static void indirect_branch_prediction_barrier(void)
{
    native_wrmsrl(MSR_IA32_PRED_CMD, PRED_CMD_IBPB);
}

/* SSBD: 추론적 저장-로드 바이패스 비활성화 (Spectre v4) */
static void ssb_disable(void)
{
    u64 msr = this_cpu_read(x86_spec_ctrl_current);
    msr |= SPEC_CTRL_SSBD;
    native_wrmsrl(MSR_IA32_SPEC_CTRL, msr);
}

/* L1D Flush: VM 진입 전 L1 데이터 캐시 플러시 (L1TF 완화) */
static void l1d_flush_force(void)
{
    native_wrmsrl(MSR_IA32_FLUSH_CMD, L1D_FLUSH);
}

가상화 MSR

Intel VMX 관련 MSR

VMX(Virtual Machine Extensions) 기능을 보고하고 제어하는 MSR입니다. KVM 모듈이 VMX 초기화 시 이 MSR들을 읽어 지원되는 기능을 확인합니다.

MSR 비트맵 (Intel VT-x)

VMCS의 MSR 비트맵은 게스트의 RDMSR/WRMSR이 VM exit를 유발할지 결정하는 4KB 비트맵입니다. 비트가 0이면 게스트가 직접 접근하고, 1이면 VM exit가 발생하여 KVM이 에뮬레이션합니다.

/* arch/x86/kvm/vmx/vmx.c — MSR 비트맵 설정 */
static void vmx_set_msr_bitmap_read(unsigned long *msr_bitmap,
                                     u32 msr, bool intercept)
{
    int f;
    if (msr <= 0x1FFF)
        f = 0;                 /* 하위 MSR 영역: 오프셋 0 */
    else if (msr >= 0xC0000000 && msr <= 0xC0001FFF)
        f = 1024;              /* 상위 MSR 영역: 오프셋 1024바이트 */
    else
        return;               /* 범위 밖 — 항상 intercept */

    msr &= 0x1FFF;
    if (intercept)
        __set_bit(msr, msr_bitmap + f / sizeof(long));
    else
        __clear_bit(msr, msr_bitmap + f / sizeof(long));
}

AMD SVM MSRPM (MSR Permission Map)

AMD SVM은 8KB MSRPM을 사용하며, 각 MSR에 대해 2비트(읽기/쓰기 각각)를 할당합니다.

KVM의 MSR 에뮬레이션

/* arch/x86/kvm/x86.c — 게스트 MSR 읽기 에뮬레이션 */
int kvm_get_msr(struct kvm_vcpu *vcpu, u32 index, u64 *data)
{
    switch (index) {
    case MSR_IA32_TSC:
        *data = kvm_read_l1_tsc(vcpu, rdtsc());
        break;
    case MSR_IA32_SPEC_CTRL:
        *data = vcpu->arch.spec_ctrl;
        break;
    case MSR_IA32_ARCH_CAPABILITIES:
        *data = vcpu->arch.arch_capabilities;
        break;
    /* ... 수십 개의 MSR 에뮬레이션 */
    default:
        return kvm_x86_ops.get_msr(vcpu, index, data);
    }
    return 0;
}

MTRR / PAT MSR

MTRR (Memory Type Range Registers)

MTRR은 물리 메모리 영역의 캐시 정책(Uncacheable, Write-Combining, Write-Through, Write-Back 등)을 설정합니다. 주로 BIOS가 초기화하며, 그래픽 프레임버퍼 등 MMIO 영역에 Write-Combining을 설정합니다.

메모리 타입 인코딩

PAT (Page Attribute Table)

PAT는 MTRR의 페이지 단위 확장으로, 페이지 테이블 엔트리의 PAT/PCD/PWT 비트 조합으로 8개 메모리 타입 중 하나를 선택합니다.

/* arch/x86/mm/pat/memtype.c — PAT 초기화 */
void pat_init(void)
{
    u64 pat;

    /* Linux 기본 PAT 설정:
     * PAT0=WB PAT1=WC PAT2=UC- PAT3=UC
     * PAT4=WB PAT5=WC PAT6=UC- PAT7=UC */
    pat = PAT(0, WB) | PAT(1, WC) | PAT(2, UC_MINUS) | PAT(3, UC) |
          PAT(4, WB) | PAT(5, WC) | PAT(6, UC_MINUS) | PAT(7, UC);
    wrmsrl(MSR_IA32_CR_PAT, pat);
}

Linux 커널 MSR API

Linux 커널은 다양한 MSR 접근 래퍼 함수를 제공합니다. 모두 arch/x86/include/asm/msr.h에 정의되어 있습니다.

기본 접근 함수

안전한(safe) 변형

존재하지 않는 MSR에 접근하면 #GP 예외가 발생합니다. safe 변형은 예외를 잡아 에러 코드를 반환합니다.

/* safe 변형 사용 예 — MSR 존재 여부 불확실할 때 */
u64 val;
int err;

err = rdmsrl_safe(MSR_IA32_ARCH_CAPABILITIES, &val);
if (err) {
    pr_info("IA32_ARCH_CAPABILITIES not supported\n");
} else {
    if (val & ARCH_CAP_RDCL_NO)
        pr_info("CPU is not vulnerable to Meltdown\n");
}

Cross-CPU MSR 접근

다른 CPU의 MSR을 읽고 쓰려면 IPI를 통해 해당 CPU에서 실행해야 합니다.

/dev/cpu/N/msr — 유저 공간 접근

CONFIG_X86_MSR=y일 때 커널은 각 CPU별로 /dev/cpu/<N>/msr 캐릭터 디바이스를 생성합니다. pread()/pwrite()의 오프셋이 MSR 주소, 데이터가 8바이트 MSR 값입니다.

/* 유저 공간 MSR 읽기 예 (root 또는 CAP_SYS_RAWIO 필요) */
#include <fcntl.h>
#include <unistd.h>

int fd = open("/dev/cpu/0/msr", O_RDONLY);
uint64_t tsc;
pread(fd, &tsc, sizeof(tsc), 0x10);  /* IA32_TSC */
printf("TSC = %llu\n", tsc);
close(fd);

AMD 전용 MSR

AMD 프로세서는 0xC0010000~0xC001FFFF 범위에 고유 MSR을 가지고 있습니다.

AMD LFENCE 직렬화

/* arch/x86/kernel/cpu/amd.c — LFENCE를 직렬화 명령어로 설정 */
static void init_amd_lfence(struct cpuinfo_x86 *c)
{
    u64 val;
    rdmsrl(MSR_AMD64_DE_CFG, val);
    if (!(val & BIT(1))) {
        val |= BIT(1);   /* LFENCE를 dispatch serializing으로 */
        wrmsrl(MSR_AMD64_DE_CFG, val);
    }
    set_cpu_cap(c, X86_FEATURE_LFENCE_RDTSC);
}

AMD SVM 관련 MSR

실전 예제

예제 1: 현재 CPU 주파수 읽기 (APERF/MPERF)

#include <linux/module.h>
#include <asm/msr.h>
#include <asm/cpu_device_id.h>

static int __init freq_init(void)
{
    u64 aperf0, aperf1, mperf0, mperf1;
    u64 tsc_khz_val = tsc_khz;
    unsigned long flags;

    local_irq_save(flags);
    rdmsrl(MSR_IA32_APERF, aperf0);
    rdmsrl(MSR_IA32_MPERF, mperf0);
    local_irq_restore(flags);

    msleep(100);  /* 100ms 대기 */

    local_irq_save(flags);
    rdmsrl(MSR_IA32_APERF, aperf1);
    rdmsrl(MSR_IA32_MPERF, mperf1);
    local_irq_restore(flags);

    /* freq = tsc_freq * delta_aperf / delta_mperf */
    u64 freq_khz = div64_u64(tsc_khz_val * (aperf1 - aperf0),
                              (mperf1 - mperf0));
    pr_info("CPU %d actual freq: %llu MHz\n",
           smp_processor_id(), freq_khz / 1000);

    return 0;
}

module_init(freq_init);
MODULE_LICENSE("GPL");

예제 2: PMU 카운터로 IPC 측정

/* 고정 카운터로 Instructions Per Cycle 측정 */
static void measure_ipc(void)
{
    u64 inst0, inst1, cycles0, cycles1;

    /* 고정 카운터 활성화: OS + USR 모드 */
    wrmsrl(MSR_CORE_PERF_FIXED_CTR_CTRL, 0x33);  /* CTR0, CTR1 활성화 */
    wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL,
          (1ULL << 32) | (1ULL << 33));  /* Fixed CTR0,1 전역 활성화 */

    rdmsrl(MSR_CORE_PERF_FIXED_CTR0, inst0);    /* Instructions Retired */
    rdmsrl(MSR_CORE_PERF_FIXED_CTR1, cycles0);  /* Unhalted Cycles */

    /* ... 측정 대상 코드 ... */

    rdmsrl(MSR_CORE_PERF_FIXED_CTR0, inst1);
    rdmsrl(MSR_CORE_PERF_FIXED_CTR1, cycles1);

    pr_info("IPC = %llu.%02llu\n",
           (inst1 - inst0) / (cycles1 - cycles0),
           ((inst1 - inst0) * 100 / (cycles1 - cycles0)) % 100);
}

예제 3: CPU 코어 온도 읽기

static int read_core_temp(int cpu)
{
    u32 eax, edx;
    int tjmax, offset;

    /* TjMax (보통 100°C) */
    rdmsr_on_cpu(cpu, MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
    tjmax = (eax >> 16) & 0xFF;

    /* Digital Readout */
    rdmsr_on_cpu(cpu, MSR_IA32_THERM_STATUS, &eax, &edx);
    if (!(eax & (1 << 31)))
        return -1;  /* 값이 유효하지 않음 */

    offset = (eax >> 16) & 0x7F;
    return tjmax - offset;  /* °C */
}

예제 4: TSC 기반 정밀 시간 측정

static inline u64 rdtsc_ordered(void)
{
    /* LFENCE + RDTSC 로 순서 보장 */
    barrier();
    return rdtsc();
}

static void benchmark(void)
{
    u64 t0, t1;
    unsigned long flags;

    local_irq_save(flags);
    t0 = rdtsc_ordered();

    /* 측정 대상 코드 */
    some_function();

    t1 = rdtsc_ordered();
    local_irq_restore(flags);

    pr_info("Elapsed: %llu cycles (%llu ns)\n",
           t1 - t0,
           div64_u64((t1 - t0) * 1000000, tsc_khz));
}

MSR 디버깅

msr-tools 패키지

유저 공간에서 MSR을 직접 읽고 쓸 수 있는 도구입니다.

# 설치 (Debian/Ubuntu)
sudo apt install msr-tools

# msr 커널 모듈 로드
sudo modprobe msr

# IA32_TSC (0x10) 읽기 — CPU 0
sudo rdmsr -p 0 0x10

# IA32_EFER (0xC0000080) 읽기 — 모든 CPU
sudo rdmsr -a 0xC0000080

# IA32_MISC_ENABLE (0x1A0) 읽기 — 비트별 출력
sudo rdmsr -p 0 -b 0x1A0

# IA32_SPEC_CTRL (0x48) 읽기 — Spectre 완화 상태
sudo rdmsr -p 0 0x48

# MSR 쓰기 (주의: 잘못된 값은 시스템 크래시 유발)
sudo wrmsr -p 0 0x48 0x7   # IBRS + STIBP + SSBD 활성화

perf 도구를 이용한 PMU 확인

# PMU 하드웨어 이벤트 목록
perf list hw cache

# PMU 카운터 직접 지정 (event=0x2E, umask=0x41 = LLC-misses)
perf stat -e r412e ./program

# MSR 기반 이벤트 추적
perf stat -e cycles,instructions,cache-misses,branch-misses ./program

# Architectural MSR 기능 확인
perf stat -e cpu/event=0x00,umask=0x01/ -- sleep 1

커널 로그에서 MSR 관련 정보

# 부팅 시 MSR 관련 메시지
dmesg | grep -i msr

# Spectre/Meltdown 완화 상태
cat /sys/devices/system/cpu/vulnerabilities/*

# MTRR 설정 확인
cat /proc/mtrr

# PAT 설정 확인
dmesg | grep -i pat

일반적 함정과 주의사항

MSR 주요 레퍼런스 테이블

자주 사용되는 ~70개 주요 MSR의 종합 레퍼런스입니다. 커널 헤더 arch/x86/include/asm/msr-index.h에서 전체 매크로를 확인할 수 있습니다.