RISC-V 명령어셋 레퍼런스 (ISA)

RISC-V 아키텍처의 명령어를 GAS 문법 기준으로 종합 정리합니다. 모듈형 ISA 설계 철학과 RV64I 기본 명령어셋, M(곱셈)/A(원자적(Atomic))/F(단정도)/D(배정도)/C(압축)/V(벡터) 표준 확장, 32개 범용 레지스터(Register)와 CSR 체계, R/I/S/B/U/J 6가지 인코딩 타입, 데이터 전송·산술·논리·분기·스택·시스템·원자적·벡터 명령어 카테고리 표, 인코딩 다이어그램, 커널 핵심 명령어(ECALL, SRET, LR/SC, SFENCE.VMA) 고급까지 Linux 커널 개발에 필요한 RISC-V ISA 전체를 다룹니다.

아키텍처 개요

RISC-V는 UC Berkeley에서 2010년 시작한 오픈소스 RISC ISA입니다. 모듈형 설계로 기본 정수 ISA(RV32I/RV64I)에 표준 확장을 선택적으로 추가합니다.

모듈형 ISA 확장 구조

RISC-V의 핵심 설계 철학은 모듈형(modular) ISA입니다. RV64I 기본 정수 명령어셋을 중심으로 필요한 확장을 선택적으로 추가하여 SoC 설계자가 목적에 맞는 최적의 프로세서를 구성할 수 있습니다. 표준 확장 조합인 RV64G(= RV64IMAFD)는 범용 운영체제 실행에 필요한 최소 세트이며, Linux 커널은 이를 기본으로 요구합니다.

레지스터 셋

범용 레지스터 (x0-x31)

레지스터 파일 시각적 맵

32개 범용 레지스터를 용도별로 그룹화하고 Caller/Callee-saved 여부를 색상으로 구분한 시각적 맵입니다. 함수 호출 시 어떤 레지스터를 저장해야 하는지 파악하는 데 유용합니다.

CSR (Control and Status Registers) — 주요

CSR 주소 공간 레이아웃

RISC-V CSR 주소는 12-bit (0x000-0xFFF)로 인코딩됩니다. 상위 비트들이 접근 권한과 특권 레벨을 결정하므로, CSR 번호만으로도 접근 가능 여부를 하드웨어가 즉시 판단할 수 있습니다.

부동소수점 / 벡터 레지스터

부동소수점과 벡터 레지스터는 정수 레지스터와 별도의 물리 레지스터 파일을 사용합니다. 따라서 정수 이름 공간(x0-x31)과 겹치지 않으며, 커널은 이 상태를 태스크별로 격리(Isolation)하여 보존합니다.

f0-f31은 호출 규약(Calling Convention)상 정수 레지스터와 마찬가지로 caller-saved/saved 그룹으로 나뉩니다. 인자 전달과 반환값은 fa0-fa7, 호출을 넘겨 유지하는 값은 fs0-fs11이 담당합니다.

NaN-boxing: F 확장만 구현한 프로세서에서도 f 레지스터의 물리 폭은 64-bit이며, 단정도 값은 상위 32-bit을 모두 1로 채워 저장합니다. D 확장이 있으면 배정도 값을 그대로 담습니다. 이 규칙 덕분에 하드웨어는 레지스터 폭을 통일한 채로 단정도/배정도 값을 구분할 수 있습니다.

fcsr 비트 구성: 비트 [7:5]는 라운딩 모드(frm: RNE/RTZ/RDN/RUP/RMM), 비트 [4:0]은 예외 플래그(fflags: NV/DZ/OF/UF/NX)입니다. 예외 플래그는 누적형(sticky)이므로 한 번 설정되면 소프트웨어가 지우기 전까지 유지됩니다.

커널의 FPU/Vector 상태 관리: 커널은 sstatus.FS 필드로 FPU 상태를 Off/Initial/Clean/Dirty로 추적하고, DIRTY일 때만 실제 레지스터를 저장합니다(fstate_save()). 벡터도 sstatus.VS 필드로 같은 방식으로 관리하며, 태스크 생성과 트랩 처리 과정에서 riscv_v_vstate_discard()로 벡터 레지스터를 무효화하여 이전 태스크의 값이 남지 않게 합니다. 이 방식은 FPU/벡터를 쓰지 않는 태스크의 컨텍스트 스위치 비용을 없애 줍니다.

주소 지정 모드

RISC-V는 매우 단순한 주소 모드를 사용합니다: 베이스 레지스터 + 12-bit 부호 확장 즉시값 오프셋(Offset)만 지원합니다.

데이터 전송 명령어

로드의 부호/제로 확장: RV64에서 메모리에서 읽은 바이트·하프워드·워드는 레지스터의 64-bit 폭에 맞게 확장되어야 합니다. LB/LH/LW는 부호 확장, LBU/LHU/LWU는 제로 확장을 수행하며, 컴파일러가 정수 타입의 부호 유무에 따라 적절한 변형을 선택합니다. 반면 저장(SB/SH/SW/SD)은 대상 폭만 지정하고 부호 개념이 없습니다.

로드/저장 예제

구조체(struct) 필드 접근은 로드 폭과 확장 규칙이 그대로 드러나는 대표적인 예다. 다음 C 코드는 필드 오프셋에 해당하는 로드 명령으로 전개됩니다.

struct packet {
    unsigned char  flag;   /* offset 0 */
    unsigned int   id;     /* offset 4 */
    unsigned long  addr;   /* offset 8 */
};

unsigned int packet_id(const struct packet *p) {
    return p->id;             /* unsigned → 제로 확장 */
}

signed char packet_flag(const struct packet *p) {
    return p->flag;           /* signed char → 부호 확장 */
}

/* packet_id: a0=p → a0 (unsigned int) */
packet_id:
    lwu     a0, 4(a0)              /* 32-bit 로드 후 제로 확장 */
    ret

/* packet_flag: a0=p → a0 (signed char) */
packet_flag:
    lb      a0, 0(a0)              /* 8-bit 로드 후 부호 확장 */
    ret

정렬(Alignment)과 misaligned 접근: RISC-V는 자연 정렬 접근을 권장하며, 정렬되지 않은 접근은 구현에 따라 트랩될 수 있습니다. Linux 커널은 CONFIG_RISCV_MISALIGNED로 misaligned 로드/저장을 소프트웨어로 에뮬레이션하고(handle_misaligned_load()/handle_misaligned_store()), SBI FWFT(Firmware Features)를 지원하는 펌웨어에서는 위임된 load/store address misaligned 예외를 커널이 직접 처리합니다. 커널 코드는 로드/저장 폭을 필요한 만큼만 쓰고 정렬을 지키는 형태를 선호합니다.

LUI + ADDI로 32-bit 상수 로딩

RISC-V 명령어의 즉시값은 최대 12-bit이므로, 더 큰 상수를 레지스터에 로드하려면 LUI(상위 20-bit)와 ADDI(하위 12-bit)를 조합해야 합니다. 여기서 주의할 점은 ADDI가 부호 확장을 수행하므로, 하위 12-bit의 MSB가 1이면 LUI에 1을 더해 보정해야 하는 것입니다.

/* 예: a0 = 0x12345678 로드 */
/* 상위 20-bit: 0x12345, 하위 12-bit: 0x678 */
/* 0x678의 MSB=0이므로 보정 불필요 */
    lui     a0, 0x12345           /* a0 = 0x12345000 */
    addi    a0, a0, 0x678         /* a0 = 0x12345678 */

/* 예: a0 = 0x12345800 로드 */
/* 하위 12-bit: 0x800, MSB=1 → ADDI가 -2048로 부호 확장 */
/* 보정: LUI에 1을 더함 (0x12345 + 1 = 0x12346) */
    lui     a0, 0x12346           /* a0 = 0x12346000 */
    addi    a0, a0, -0x800        /* a0 = 0x12346000 - 0x800 = 0x12345800 */

/* 어셈블러 의사 명령어 li가 이를 자동 처리: */
    li      a0, 0x12345800        /* 어셈블러가 위 보정을 자동 수행 */

산술 명령어

산술 명령어 C↔어셈블리 대응 예제

RISC-V 산술 명령어의 핵심 특징은 세 피연산자(Operand) 형식과 MOD 전용 명령어 존재입니다. ARM64와 달리 REM 명령어가 있어 나머지 계산이 1 명령어로 가능합니다. 또한 RV64에서 ADDW/SUBW는 32-bit 연산 후 자동으로 64-bit 부호 확장하여 하위 호환성을 유지합니다.

/* 예제 1: 기본 사칙연산 — RV64 W-suffix 명령어 */
int add32(int a, int b) {    /* 32-bit 정수 */
    return a + b;
}

long add64(long a, long b) { /* 64-bit 정수 */
    return a + b;
}

long div_rem(long a, long b, long *rem) {
    *rem = a % b;
    return a / b;
}

/* add32: a0=a, a1=b → a0 (32-bit 덧셈, 부호 확장) */
add32:
    addw    a0, a0, a1            /* 32-bit 덧셈 + 64-bit 부호 확장 */
    ret                           /* (= ra 점프) */

/* add64: a0=a, a1=b → a0 (64-bit 덧셈) */
add64:
    add     a0, a0, a1            /* 64-bit 덧셈 */
    ret

/* div_rem: a0=a, a1=b, a2=rem* → a0=몫, *a2=나머지 */
div_rem:
    rem     t0, a0, a1            /* t0 = a % b */
    div     a0, a0, a1            /* a0 = a / b (몫) */
    sd      t0, 0(a2)             /* *rem = 나머지 저장 */
    ret

/* 예제 2: 128-bit 곱셈 (암호화 연산에서 활용) */
typedef unsigned long u64;
typedef unsigned __int128 u128;

u128 mul128(u64 a, u64 b) {
    return (u128)a * b;
}

/* mul128: a0=a, a1=b → a1:a0 (a1=상위, a0=하위) */
mul128:
    mulhu   a2, a0, a1            /* a2 = 상위 64-bit (unsigned high) */
    mul     a0, a0, a1            /* a0 = 하위 64-bit */
    mv      a1, a2                 /* a1 = 상위 64-bit (반환 규약) */
    ret

/* 예제 3: FMA (Fused Multiply-Add) — D 확장 (배정도) */
double fma_op(double a, double b, double c) {
    return a * b + c;   /* IEEE 754 FMA: 중간 반올림 없음 */
}

/* fma_op: fa0=a, fa1=b, fa2=c → fa0 (D 확장, double) */
fma_op:
    fmadd.d fa0, fa0, fa1, fa2    /* fa0 = fa0*fa1 + fa2 (단일 명령어 FMA) */
    ret

논리/시프트/비트 조작 명령어

비교/분기 명령어

주요 의사 명령어(pseudo-instruction) 확장 표

RISC-V 어셈블러는 프로그래머 편의를 위해 다양한 의사 명령어를 제공합니다. 아래 표는 자주 사용되는 의사 명령어와 그것이 실제로 확장되는 기본 명령어를 보여줍니다.

스택/함수 호출 명령어

RISC-V에는 PUSH/POP이 없습니다. addi sp와 sd/ld로 수동 관리합니다.

/* 함수 프롤로그/에필로그 */
my_func:
    addi    sp, sp, -32           /* 스택 프레임 할당 */
    sd      ra, 24(sp)             /* 복귀 주소 저장 */
    sd      s0, 16(sp)             /* 프레임 포인터 저장 */
    addi    s0, sp, 32             /* 프레임 포인터 설정 */
    /* ... 함수 본문 ... */
    ld      s0, 16(sp)             /* 프레임 포인터 복원 */
    ld      ra, 24(sp)             /* 복귀 주소 복원 */
    addi    sp, sp, 32             /* 스택 프레임 해제 */
    ret                             /* jalr zero, 0(ra) */

시스템/특권 명령어

트랩 위임(Trap Delegation) 메커니즘

기본적으로 모든 트랩은 M-mode로 전달되지만, medeleg(예외 위임)와 mideleg(인터럽트 위임) CSR을 설정하면 특정 트랩을 S-mode에서 직접 처리할 수 있습니다. Linux 부팅 시 SBI(OpenSBI 등)가 이 위임을 설정합니다.

SFENCE.VMA 변형 (TLB 무효화)

SFENCE.VMA는 인자에 따라 무효화 범위가 달라집니다. 불필요하게 넓은 범위를 플러시(Flush)하면 성능 저하가 발생하므로, 커널은 가능한 한 좁은 범위의 무효화를 사용합니다.

Sv39 페이지 테이블 워크 구조

Linux RISC-V는 주로 Sv39 (39-bit 가상 주소, 3단계 페이지 테이블)를 사용합니다. satp CSR이 루트 페이지 테이블의 물리 주소(Physical Address)와 ASID를 저장합니다.

원자적/동기화 명령어 (A 확장)

LR/SC CAS 루프 패턴

/* compare_and_swap(addr=a0, expected=a1, desired=a2) → old in a0 */
cas_loop:
    lr.d.aq  a3, (a0)             /* Load-Reserved + Acquire */
    bne      a3, a1, 1f           /* expected와 다르면 실패 */
    sc.d.rl  a4, a2, (a0)          /* Store-Conditional + Release */
    bnez     a4, cas_loop          /* SC 실패 시 재시도 */
1:
    mv       a0, a3               /* 이전 값 반환 */
    ret

AMOSWAP 기반 스핀락 구현

/* 스핀락: lock=a0 (0=해제, 1=잠김) */
spin_lock:
    li       t0, 1
1:
    amoswap.w.aq t1, t0, (a0)      /* t1 = old, *a0 = 1 (acquire) */
    bnez     t1, 1b               /* 이미 잠겨있으면 재시도 */
    ret                             /* 획득 성공, acquire 의미론 보장 */

spin_unlock:
    amoswap.w.rl zero, zero, (a0)  /* *a0 = 0, release 의미론 */
    ret

/* 최적화된 버전: test-and-set with backoff */
spin_lock_optimized:
    li       t0, 1
1:  lw       t1, (a0)              /* 일반 로드로 먼저 확인 (캐시 친화적) */
    bnez     t1, 1b               /* 잠겨있으면 바쁜 대기 */
    amoswap.w.aq t1, t0, (a0)      /* 해제된 것 같으면 시도 */
    bnez     t1, 1b               /* 실패 시 다시 대기 */
    ret

벡터 명령어 (V 확장)

RISC-V V 확장은 가변 길이 벡터(VLEN: 구현 의존, 128-bit 이상)를 지원합니다. vsetvli로 벡터 길이와 요소 타입을 동적으로 설정합니다.

LMUL (Length MULtiplier) 개념

LMUL은 하나의 벡터 연산이 사용하는 레지스터 그룹의 크기를 결정합니다. LMUL=1이면 단일 레지스터, LMUL=2이면 연속 2개 레지스터를 하나의 벡터로 묶어 더 긴 벡터를 처리합니다. 반대로 LMUL=1/2, 1/4, 1/8 분수값도 가능하여 좁은 요소를 효율적으로 처리합니다.

vsetvli와 VLEN/SEW/LMUL 관계

vsetvli 명령어는 벡터 연산 전에 반드시 호출하여 SEW(Selected Element Width)와 LMUL을 설정합니다. 하드웨어는 요청된 벡터 길이(AVL)와 VLMAX를 비교하여 실제 처리할 요소 수(VL)를 결정합니다.

/* vsetvli rd, rs1, vtypei */
/* rd: 실제 설정된 벡터 길이 (VL) */
/* rs1: 요청하는 벡터 길이 (AVL). rs1=zero이면 VL 변경 없이 vtype만 변경 */
/* vtypei: SEW, LMUL, ta(tail agnostic), ma(mask agnostic) 인코딩 */

/* 예: SEW=8, LMUL=1, tail-agnostic, mask-agnostic */
    vsetvli  t0, a2, e8, m1, ta, ma  /* t0 = min(a2, VLMAX) */

/* SEW 옵션: e8(8-bit), e16(16-bit), e32(32-bit), e64(64-bit) */
/* LMUL 옵션: mf8(1/8), mf4(1/4), mf2(1/2), m1(1), m2(2), m4(4), m8(8) */
/* 꼬리 정책: ta(tail agnostic) / tu(tail undisturbed) */
/* 마스크 정책: ma(mask agnostic) / mu(mask undisturbed) */

벡터화된 memcpy 예제

RISC-V V 확장의 강력한 점은 vsetvli 스트립마이닝 루프입니다. 하드웨어가 한 번에 처리할 수 있는 최대 요소 수를 자동으로 결정하므로, VLEN에 독립적인 코드를 작성할 수 있습니다.

/* void *memcpy_v(void *dst, const void *src, size_t n) */
/* a0=dst, a1=src, a2=n (바이트 수) */
memcpy_v:
    mv       a3, a0                /* 반환용 dst 주소 보존 */
.Lloop:
    vsetvli  t0, a2, e8, m8, ta, ma /* t0 = 이번에 복사할 바이트 수 */
                                      /* SEW=8(바이트), LMUL=8(최대 처리량) */
    vle8.v   v0, (a1)              /* src에서 t0 바이트 로드 */
    vse8.v   v0, (a0)              /* dst에 t0 바이트 저장 */
    add      a1, a1, t0            /* src += t0 */
    add      a0, a0, t0            /* dst += t0 */
    sub      a2, a2, t0            /* n -= t0 */
    bnez     a2, .Lloop            /* 남은 바이트가 있으면 반복 */
    mv       a0, a3                /* dst 주소 반환 */
    ret

커널 핵심 명령어

ECALL — SBI 호출 패턴

/* SBI 호출: a7=EID, a6=FID, a0-a5=인자 */
/* 반환: a0=error, a1=value */
    li      a7, 0x10              /* SBI_EXT_BASE */
    li      a6, 0                  /* SBI_BASE_GET_SPEC_VERSION */
    ecall                            /* S-mode → M-mode 트랩 */
    /* a0=error code, a1=spec version */

트랩 핸들러 진입

/* stvec → _handle_exception */
_handle_exception:
    csrrw   tp, sscratch, tp       /* tp ↔ sscratch 교환 */
    /* tp는 이제 커널 task_struct, sscratch는 유저 tp */
    sd      sp, TASK_TI_USER_SP(tp)    /* 유저 sp 저장 */
    ld      sp, TASK_TI_KERNEL_SP(tp)  /* 커널 스택으로 전환 */
    addi    sp, sp, -PT_SIZE       /* pt_regs 공간 할당 */
    /* 레지스터 저장... */
    sd      ra, PT_RA(sp)
    sd      gp, PT_GP(sp)
    /* ... a0-a7, s0-s11, t0-t6 저장 ... */
    csrr    a0, scause             /* 트랩 원인 */
    csrr    a1, sepc               /* 예외 PC */
    csrr    a2, stval              /* 트랩 값 */

SRET — 트랩 복귀

    /* 레지스터 복원 후 */
    csrw    sepc, a0               /* 복귀 PC 설정 */
    csrw    sstatus, a1            /* 상태 복원 */
    csrrw   tp, sscratch, tp       /* tp ↔ sscratch 복원 */
    sret                            /* PC←sepc, 모드←sstatus.SPP */

SFENCE.VMA — TLB 무효화

/* arch/riscv/include/asm/tlbflush.h */
static inline void local_flush_tlb_page(unsigned long addr)
{
    asm volatile("sfence.vma %0" :: "r"(addr) : "memory");
}
static inline void local_flush_tlb_all(void)
{
    asm volatile("sfence.vma" ::: "memory");
}

SBI (Supervisor Binary Interface) 확장 표

SBI는 S-mode(커널)가 M-mode(펌웨어)의 서비스를 호출하는 표준 인터페이스입니다. RISC-V에서 ARM의 PSCI나 x86의 BIOS 서비스에 해당하며, OpenSBI가 대표적 구현체입니다. 호출 규약은 a7=EID(Extension ID), a6=FID(Function ID), a0-a5=인자, 반환은 a0=error, a1=value입니다.

완전한 컨텍스트 스위치 예제

Linux 커널의 __switch_to()는 프로세스 간 컨텍스트를 전환합니다. RISC-V에서는 callee-saved 레지스터(s0-s11, sp, ra)만 저장/복원하면 됩니다 (caller-saved는 C 호출 규약에 의해 호출자가 이미 처리).

/* arch/riscv/kernel/entry.S — __switch_to(prev, next) */
/* a0 = prev->thread (struct thread_struct *) */
/* a1 = next->thread (struct thread_struct *) */
__switch_to:
    /* === prev 컨텍스트 저장 === */
    sd      ra,  THREAD_RA(a0)     /* 복귀 주소 */
    sd      sp,  THREAD_SP(a0)     /* 스택 포인터 */
    sd      s0,  THREAD_S0(a0)     /* callee-saved s0 (fp) */
    sd      s1,  THREAD_S1(a0)
    sd      s2,  THREAD_S2(a0)
    sd      s3,  THREAD_S3(a0)
    sd      s4,  THREAD_S4(a0)
    sd      s5,  THREAD_S5(a0)
    sd      s6,  THREAD_S6(a0)
    sd      s7,  THREAD_S7(a0)
    sd      s8,  THREAD_S8(a0)
    sd      s9,  THREAD_S9(a0)
    sd      s10, THREAD_S10(a0)
    sd      s11, THREAD_S11(a0)

    /* === next 컨텍스트 복원 === */
    ld      ra,  THREAD_RA(a1)     /* next의 복귀 주소 */
    ld      sp,  THREAD_SP(a1)     /* next의 스택 */
    ld      s0,  THREAD_S0(a1)
    ld      s1,  THREAD_S1(a1)
    ld      s2,  THREAD_S2(a1)
    ld      s3,  THREAD_S3(a1)
    ld      s4,  THREAD_S4(a1)
    ld      s5,  THREAD_S5(a1)
    ld      s6,  THREAD_S6(a1)
    ld      s7,  THREAD_S7(a1)
    ld      s8,  THREAD_S8(a1)
    ld      s9,  THREAD_S9(a1)
    ld      s10, THREAD_S10(a1)
    ld      s11, THREAD_S11(a1)

    /* tp(스레드 포인터)를 next의 task_struct로 전환 */
    mv      tp, a2                 /* a2 = next task_struct */

    ret                             /* ra가 next의 복귀 주소이므로 next 프로세스로 점프 */

SFENCE.VMA 커널 사용 패턴

/* 1. 단일 페이지 매핑 변경 후 */
static inline void local_flush_tlb_page(unsigned long addr)
{
    /* 해당 가상 주소의 TLB 엔트리만 무효화 */
    asm volatile("sfence.vma %0" :: "r"(addr) : "memory");
}

/* 2. 프로세스 전체 주소 공간 무효화 (특정 ASID) */
static inline void local_flush_tlb_all_asid(unsigned long asid)
{
    asm volatile("sfence.vma zero, %0" :: "r"(asid) : "memory");
}

/* 3. 전체 TLB 플러시 (satp 변경 후) */
static inline void local_flush_tlb_all(void)
{
    asm volatile("sfence.vma" ::: "memory");
}

/* 4. 원격 TLB 무효화 (SBI를 통해 다른 hart에 IPI 전송) */
void flush_tlb_range(struct vm_area_struct *vma,
                     unsigned long start, unsigned long end)
{
    /* SBI RFENCE 확장 사용 */
    /* 로컬 hart: sfence.vma */
    /* 원격 hart: sbi_remote_sfence_vma() IPI */
}

명령어 인코딩

RISC-V는 6가지 기본 인코딩 타입을 사용합니다. 모든 타입에서 opcode는 [6:0], rd는 [11:7]에 위치하여 디코딩을 단순화합니다.

인코딩 예제: add a0, a1, a2

add a0, a1, a2는 R-type 인코딩입니다. 각 필드가 어떻게 매핑되는지 구체적으로 보겠습니다.

add a0, a1, a2의 32-bit 인코딩은 다음과 같습니다.

 funct7  | rs2   | rs1   | f3  | rd    | opcode
 0000000 | 01100 | 01011 | 000 | 01010 | 0110011
 = 0x00C58533

검증: objdump 출력에서 0: 00c58533 add a0, a1, a2로 확인할 수 있습니다.

비교: sub a0, a1, a2는 funct7만 다릅니다 (0100000).

 funct7  | rs2   | rs1   | f3  | rd    | opcode
 0100000 | 01100 | 01011 | 000 | 01010 | 0110011
 = 0x40C58533

SBI (Supervisor Binary Interface)

SBI는 S-mode(리눅스 커널)가 M-mode(펌웨어, OpenSBI)에 서비스를 요청하는 표준 인터페이스입니다. x86의 BIOS/UEFI Runtime Services, ARM의 PSCI(Power State Coordination Interface)에 대응하며, RISC-V 커널이 하드웨어 추상화 없이 이식성을 확보하는 핵심 메커니즘입니다.

/* arch/riscv/kernel/sbi.c — SBI 호출 구현 */
struct sbiret sbi_ecall(int ext, int fid,
                       unsigned long arg0, unsigned long arg1,
                       unsigned long arg2, unsigned long arg3,
                       unsigned long arg4, unsigned long arg5)
{
    struct sbiret ret;
    register unsigned long a0 asm("a0") = arg0;
    register unsigned long a1 asm("a1") = arg1;
    register unsigned long a2 asm("a2") = arg2;
    register unsigned long a3 asm("a3") = arg3;
    register unsigned long a4 asm("a4") = arg4;
    register unsigned long a5 asm("a5") = arg5;
    register unsigned long a6 asm("a6") = fid;
    register unsigned long a7 asm("a7") = ext;

    asm volatile ("ecall"
        : "+r" (a0), "+r" (a1)
        : "r" (a2), "r" (a3), "r" (a4), "r" (a5),
          "r" (a6), "r" (a7)
        : "memory");

    ret.error = a0;  /* SBI_SUCCESS=0, SBI_ERR_FAILED=-1, ... */
    ret.value = a1;
    return ret;
}

/* SMP 부팅: HSM 확장으로 다른 hart 시작 */
/* sbi_hart_start(hartid, start_addr, opaque) */
/* → M-mode에서 해당 hart를 start_addr로 점프시킴 */
/* → secondary_start_sbi() → 커널 진입 */

가상 메모리 (Sv39/Sv48/Sv57)

RISC-V의 가상 메모리는 satp CSR로 제어되며, Sv39(39비트 VA, 3레벨), Sv48(48비트 VA, 4레벨), Sv57(57비트 VA, 5레벨) 모드를 지원합니다. 리눅스 커널은 RV64에서 하드웨어가 지원하는 최상위 모드(Sv57 → Sv48 → Sv39 순)를 기본으로 선택하며, no5lvl/no4lvl 부팅 옵션으로 제한할 수 있습니다.

RISC-V 호출 규약 (ilp32/lp64)

RISC-V의 호출 규약은 ABI(Application Binary Interface)의 핵심으로, 함수 호출 시 인자 전달, 반환값, 레지스터 보존 규칙을 정의합니다. RV32에서는 ilp32(int/long/pointer 32비트), RV64에서는 lp64(long/pointer 64비트) ABI를 사용하며, 부동소수점 확장에 따라 ilp32f/ilp32d, lp64f/lp64d 변형이 존재합니다. Linux 커널은 RV64에서 lp64/lp64d를 사용합니다.

레지스터 사용 규약 다이어그램

아래 다이어그램은 RISC-V 호출 규약에 따른 32개 범용 레지스터의 역할 분류를 보여줍니다. 인자 레지스터(a0-a7), 반환값(a0-a1), Callee-saved(s0-s11), Caller-saved(t0-t6), 그리고 특수 용도 레지스터(ra, sp, gp, tp)의 관계를 한눈에 파악할 수 있습니다.

C 함수 호출 규약 어셈블리 예제

/* C: long result = my_func(arg1, arg2, arg3, arg4); */
/* lp64 ABI: 인자를 a0-a7에 전달, 반환값은 a0 (128비트는 a0:a1) */

    /* caller 측: 인자 설정 */
    mv      a0, s2                 /* arg1 */
    mv      a1, s3                 /* arg2 */
    mv      a2, s4                 /* arg3 */
    mv      a3, s5                 /* arg4 */
    jal     ra, my_func            /* 함수 호출, ra ← 복귀 주소 */
    mv      s6, a0                 /* 반환값 저장 */

/* callee 측: my_func */
my_func:
    addi    sp, sp, -32           /* 스택 프레임 할당 */
    sd      ra, 24(sp)            /* ra 저장 */
    sd      s0, 16(sp)            /* s0/fp 저장 */
    sd      s1, 8(sp)             /* s1 저장 (사용하는 경우) */
    addi    s0, sp, 32            /* 프레임 포인터 설정 */

    /* 함수 본체: a0-a3에 인자 접근 */
    add     a0, a0, a1            /* 연산 */

    /* 에필로그 */
    ld      s1, 8(sp)
    ld      s0, 16(sp)
    ld      ra, 24(sp)
    addi    sp, sp, 32
    ret                            /* jalr zero, ra, 0 */

ilp32 vs lp64 ABI 차이

/* arch/riscv/include/asm/asm.h */
/* ABI에 따라 load/store 매크로가 자동 선택됨 */
#ifdef CONFIG_64BIT
#define REG_S      sd          /* 64비트: store doubleword */
#define REG_L      ld          /* 64비트: load doubleword */
#define REG_SIZE   8
#else
#define REG_S      sw          /* 32비트: store word */
#define REG_L      lw          /* 32비트: load word */
#define REG_SIZE   4
#endif

트랩/예외 처리 흐름

RISC-V의 트랩(trap) 메커니즘은 예외(exception)와 인터럽트(interrupt)를 통합적으로 처리합니다. S-mode에서 트랩이 발생하면 하드웨어가 자동으로 관련 CSR들을 설정하고 stvec에 지정된 핸들러로 점프합니다. stvec는 Direct 모드(모든 트랩이 동일 주소)와 Vectored 모드(인터럽트는 원인별 오프셋 점프)를 지원합니다.

트랩 처리 흐름 다이어그램

트랩 벡터 설정 (stvec)

/* arch/riscv/kernel/head.S — stvec 초기 설정 */
    la      t0, handle_exception   /* 핸들러 주소 로드 */
    csrw    stvec, t0              /* Direct 모드 (MODE=0) */
    /* Vectored 모드 설정 시: */
    /* ori t0, t0, 1 → stvec에 MODE=1 설정 */

/* arch/riscv/kernel/entry.S — Direct 모드 핸들러 */
SYM_CODE_START(handle_exception)
    /* sscratch에는 커널 모드면 0, 유저 모드면 task_struct 포인터 */
    csrrw   tp, CSR_SCRATCH, tp    /* tp ↔ sscratch 교환 */
    bnez    tp, _save_context      /* 유저 모드에서 온 경우 */
    /* 커널 모드에서 온 경우: tp 복원 */
    csrr    tp, CSR_SCRATCH        /* 원래 tp 복원 */
_save_context:
    /* pt_regs 프레임 할당 및 레지스터 저장 */
    REG_S   ra, PT_RA(sp)
    REG_S   gp, PT_GP(sp)
    /* ... 나머지 레지스터 저장 ... */
SYM_CODE_END(handle_exception)

예외 디스패치(Dispatch) 테이블

excp_vect_table은 C 배열이 아니라 arch/riscv/kernel/entry.S에 정의된 어셈블리 포인터 테이블입니다. handle_exception은 scause를 인덱스로 삼아 테이블 항목을 읽고, 범위 검사를 통과한 뒤 해당 핸들러로 직접 점프합니다. 테이블 범위를 벗어난 원인은 do_trap_unknown으로 넘기며, 인터럽트는 테이블을 거치지 않고 do_irq()로 곧장 갑니다.

/* arch/riscv/kernel/entry.S — handle_exception의 인덱싱과 범위 검사 */
    /* scause 최상위 비트가 0이면 예외, 1이면 인터럽트 */
    bge     s4, zero, 1f
    call    do_irq                 /* 인터럽트: 테이블 미사용 */
    j       ret_from_exception
1:  /* 예외: scause에 포인터 크기를 곱해 바이트 오프셋으로 변환 */
    slli    t0, s4, RISCV_LGPTR
    la      t1, excp_vect_table
    la      t2, excp_vect_table_end
    add     t0, t1, t0
    bgeu    t0, t2, 3f            /* 테이블 범위 검사 */
    REG_L   t1, 0(t0)
2:  jalr    t1                    /* 원인별 핸들러 호출 */
    j       ret_from_exception
3:  la      t1, do_trap_unknown   /* 범위 밖 원인: 폴백 핸들러 */
    j       2b

/* arch/riscv/kernel/entry.S — 원인 번호별 핸들러 테이블 */
/* 인덱스 = scause 예외 코드 (arch/riscv/include/asm/csr.h EXC_*) */
    .align  LGREG
SYM_DATA_START_LOCAL(excp_vect_table)
    RISCV_PTR do_trap_insn_misaligned          /* 0 */
    ALT_INSN_FAULT(RISCV_PTR do_trap_insn_fault)    /* 1 */
    RISCV_PTR do_trap_insn_illegal              /* 2 */
    RISCV_PTR do_trap_break                      /* 3 */
    RISCV_PTR do_trap_load_misaligned            /* 4 */
    RISCV_PTR do_trap_load_fault                 /* 5 */
    RISCV_PTR do_trap_store_misaligned           /* 6 */
    RISCV_PTR do_trap_store_fault                /* 7 */
    RISCV_PTR do_trap_ecall_u                    /* 8: system call */
    RISCV_PTR do_trap_ecall_s                    /* 9 */
    RISCV_PTR do_trap_unknown                    /* 10 */
    RISCV_PTR do_trap_ecall_m                    /* 11 */
    ALT_PAGE_FAULT(RISCV_PTR do_page_fault)          /* 12: instruction page fault */
    RISCV_PTR do_page_fault                      /* 13: load page fault */
    RISCV_PTR do_trap_unknown                    /* 14 */
    RISCV_PTR do_page_fault                      /* 15: store page fault */
    RISCV_PTR do_trap_unknown                    /* cause=16 */
    RISCV_PTR do_trap_unknown                    /* cause=17 */
    RISCV_PTR do_trap_software_check             /* cause=18: software check */
    RISCV_PTR do_trap_hardware_error             /* hardware error (19) */
SYM_DATA_END_LABEL(excp_vect_table, SYM_L_LOCAL, excp_vect_table_end)
/* ALT_* 항목은 errata 설정에 따라 SiFive 전용 핸들러로 대체된다 */

/* arch/riscv/kernel/traps.c — 디스패치가 아닌 미처리 예외 핸들러 */
/* do_trap_unknown은 테이블을 인덱싱하지 않는다. DO_ERROR_INFO 매크로가 */
/* 생성한 핸들러로, 유저 모드 예외에는 SIGILL/ILL_ILLTRP 시그널을 보내고, */
/* 커널 모드 예외에는 fixup_exception() 실패 시 die()를 호출한다. */
DO_ERROR_INFO(do_trap_unknown,
    SIGILL, ILL_ILLTRP, "unknown exception");

scause 예외/인터럽트 코드

커널 어셈블리 실전 예제

RISC-V Linux 커널의 핵심 어셈블리 코드를 분석합니다. 시스템 콜(System Call) 진입, 컨텍스트 스위치, 원자적 연산(Atomic Operation), 유저 공간 접근, TLB 플러시 등 커널 동작의 근간을 이루는 어셈블리 구현을 실전 코드 기반으로 상세히 다룹니다.

시스템 콜 진입 (entry.S)

/* arch/riscv/kernel/entry.S — handle_exception (트랩 진입) */
/* 유저 모드에서 ecall 실행 시 scause = 8 (EXC_U_ECALL)로 트랩 발생 */
SYM_CODE_START(handle_exception):
    /* sepc(트랩을 유발한 명령어 주소)를 pt_regs에 저장 */
    csrr    s2, CSR_EPC
    REG_S   s2, PT_EPC(sp)
    csrr    s4, CSR_CAUSE          /* scause */
    move    a0, sp                 /* pt_regs 포인터 전달 */

    /* scause 최상위 비트가 0이면 예외, 1이면 인터럽트 */
    bge     s4, zero, 1f
    call    do_irq                 /* 인터럽트 처리 */
    j       ret_from_exception
1:  /* 예외: scause를 인덱스로 벡터 테이블 조회 */
    slli    t0, s4, RISCV_LGPTR
    la      t1, excp_vect_table
    add     t0, t1, t0
    REG_L   t1, 0(t0)
    jalr    t1                     /* scause=8 → do_trap_ecall_u */

/* arch/riscv/kernel/traps.c — 시스템 콜 처리는 C로 구현 */
void do_trap_ecall_u(struct pt_regs *regs)
{
    long syscall = regs->a7;

    regs->epc += 4;              /* ecall 명령어 다음 주소로 복귀 */
    regs->orig_a0 = regs->a0;      /* 원본 a0 보존 (재시작용) */
    regs->a0 = -ENOSYS;            /* 기본 반환값 */

    if (syscall >= 0 && syscall < NR_syscalls)
        syscall_handler(regs, syscall);   /* sys_call_table[syscall] 호출 */
}

컨텍스트 스위치 (__switch_to)

/* arch/riscv/kernel/entry.S — __switch_to */
/* a0 = prev task_struct, a1 = next task_struct */
SYM_FUNC_START(__switch_to)
    /* prev 태스크의 callee-saved 레지스터 저장 */
    sd      ra,  TASK_THREAD_RA(a0)
    sd      sp,  TASK_THREAD_SP(a0)
    sd      s0,  TASK_THREAD_S0(a0)
    sd      s1,  TASK_THREAD_S1(a0)
    sd      s2,  TASK_THREAD_S2(a0)
    sd      s3,  TASK_THREAD_S3(a0)
    sd      s4,  TASK_THREAD_S4(a0)
    sd      s5,  TASK_THREAD_S5(a0)
    sd      s6,  TASK_THREAD_S6(a0)
    sd      s7,  TASK_THREAD_S7(a0)
    sd      s8,  TASK_THREAD_S8(a0)
    sd      s9,  TASK_THREAD_S9(a0)
    sd      s10, TASK_THREAD_S10(a0)
    sd      s11, TASK_THREAD_S11(a0)

    /* next 태스크의 callee-saved 레지스터 복원 */
    ld      ra,  TASK_THREAD_RA(a1)
    ld      sp,  TASK_THREAD_SP(a1)
    ld      s0,  TASK_THREAD_S0(a1)
    ld      s1,  TASK_THREAD_S1(a1)
    /* ... s2-s11 복원 생략 ... */

    /* tp를 next 태스크로 전환 */
    mv      tp, a1                 /* current task = next */

    /* sscratch에 next task 포인터 저장 (트랩 시 사용) */
    csrw    CSR_SCRATCH, tp

    ret                            /* next 태스크의 ra로 복귀 */
SYM_FUNC_END(__switch_to)

원자적 연산: LR/SC 루프와 AMO

/* arch/riscv/include/asm/atomic.h — atomic_add */
/* LR/SC (Load-Reserved / Store-Conditional) 패턴 */
atomic_add:                       /* a0=val, a1=&atomic_t */
1:
    lr.w    t0, (a1)               /* Load-Reserved: t0 ← *a1, reservation 설정 */
    add     t1, t0, a0             /* t1 = 기존 값 + 추가 값 */
    sc.w    t2, t1, (a1)           /* Store-Conditional: *a1 ← t1 (조건부) */
    bnez    t2, 1b                 /* sc 실패(≠0) 시 재시도 */
    ret

/* AMO (Atomic Memory Operation) — 더 간단한 패턴 */
atomic_add_amo:                   /* a0=val, a1=&atomic_t */
    amoadd.w zero, a0, (a1)       /* *a1 += a0, 원래 값 버림 */
    ret

/* atomic_fetch_add: 이전 값 반환 */
atomic_fetch_add:
    amoadd.w.aqrl a0, a0, (a1)   /* a0 = 이전 값, acquire+release */
    ret

/* cmpxchg: LR/SC 기반 compare-and-exchange */
cmpxchg:                          /* a0=&val, a1=expected, a2=new */
1:
    lr.d.aq t0, (a0)               /* Load-Reserved with acquire */
    bne     t0, a1, 2f             /* expected와 불일치 시 실패 */
    sc.d.rl t1, a2, (a0)           /* Store-Conditional with release */
    bnez    t1, 1b                 /* sc 실패 시 재시도 */
2:
    mv      a0, t0                 /* 이전 값 반환 */
    ret

유저 공간 접근 (copy_to_user)

/* arch/riscv/lib/uaccess.S — __asm_copy_to_user */
/* a0=dst(user), a1=src(kernel), a2=len */
SYM_FUNC_START(__asm_copy_to_user)
    /* 유저 주소 범위 확인은 C 래퍼에서 수행 */
    beqz    a2, 3f                 /* len=0이면 즉시 리턴 */
1:
    lb      t0, 0(a1)              /* 커널 메모리 로드 */
2:
    sb      t0, 0(a0)              /* 유저 메모리 저장 (fault 가능) */
    addi    a0, a0, 1
    addi    a1, a1, 1
    addi    a2, a2, -1
    bnez    a2, 1b
3:
    mv      a0, a2                 /* 남은 바이트 수 반환 (0=성공) */
    ret

    /* fixup: 유저 접근 fault 시 여기로 점프 */
    _ASM_EXTABLE(1b, 3b)            /* 로드 fault → 남은 바이트 반환 */
    _ASM_EXTABLE(2b, 3b)            /* 저장 fault → 남은 바이트 반환 */
SYM_FUNC_END(__asm_copy_to_user)

TLB 플러시 (sfence.vma)

/* arch/riscv/mm/tlbflush.c — SBI 기반 원격 TLB 플러시 */
/* 로컬 TLB 플러시: 어셈블리 인라인 */

/* sfence.vma rs1, rs2 변형: */
    sfence.vma  zero, zero         /* 전체 TLB 플러시 (모든 ASID) */
    sfence.vma  a0, zero           /* VA 기반: 주소 a0의 TLB 엔트리 */
    sfence.vma  zero, a1           /* ASID 기반: a1 ASID의 모든 엔트리 */
    sfence.vma  a0, a1             /* VA+ASID: 가장 세밀한 플러시 */

/* 리모트 TLB 플러시: SBI IPI 사용 */
/* flush_tlb_range()는 SBI_EXT_RFENCE로 다른 하트에 IPI 전송 */
/*   → sbi_remote_sfence_vma(cpumask, start, size) */
/*   → 각 타겟 하트에서 sfence.vma 실행 */

PLIC/CLINT/ACLINT 인터럽트 컨트롤러(Interrupt Controller)

RISC-V 시스템의 인터럽트 컨트롤러 아키텍처는 세 가지 주요 구성 요소로 이루어집니다. CLINT(Core-Local Interruptor)는 타이머와 소프트웨어 인터럽트(IPI)를 처리하고, PLIC(Platform-Level Interrupt Controller)는 외부 장치 인터럽트를 하트(hart)로 라우팅합니다. 최신 스펙에서는 CLINT를 대체하는 ACLINT(Advanced CLINT)와 PLIC를 대체하는 APLIC(Advanced PLIC) + IMSIC(Incoming MSI Controller) 조합이 정의되어 있습니다.

PLIC 아키텍처 다이어그램

PLIC 레지스터 접근

/* drivers/irqchip/irq-sifive-plic.c */
struct plic_priv {
    void __iomem *regs;
    unsigned long plic_quirks;
};

/* 인터럽트 Claim (읽기) */
static u32 plic_claim(struct plic_handler *handler)
{
    return readl(handler->hart_base + CONTEXT_CLAIM);
}

/* 인터럽트 Complete (쓰기) */
static void plic_complete(struct plic_handler *handler, u32 hwirq)
{
    writel(hwirq, handler->hart_base + CONTEXT_CLAIM);
}

/* PLIC IRQ 핸들러 — chained handler */
static void plic_handle_irq(struct irq_desc *desc)
{
    struct plic_handler *handler = this_cpu_ptr(&plic_handlers);
    u32 hwirq;

    chained_irq_enter(chip, desc);
    while ((hwirq = plic_claim(handler))) {
        int irq = irq_find_mapping(handler->priv->irqdomain, hwirq);
        if (unlikely(irq <= 0))
            pr_warn("unexpected irq %d\n", hwirq);
        else
            generic_handle_irq(irq);
        plic_complete(handler, hwirq);
    }
    chained_irq_exit(chip, desc);
}

CLINT 타이머/IPI 설정

/* CLINT MMIO 레지스터 레이아웃 */
/* 0x0000: msip[hart]     — 소프트웨어 인터럽트 (IPI) */
/* 0x4000: mtimecmp[hart] — 타이머 비교 레지스터 */
/* 0xBFF8: mtime          — 글로벌 타이머 카운터 */

/* drivers/clocksource/timer-riscv.c — riscv_clock_next_event() */
static int riscv_clock_next_event(unsigned long delta,
                                  struct clock_event_device *ce)
{
    u64 next_tval = get_cycles64() + delta;

    if (static_branch_likely(&riscv_sstc_available)) {
        /* Sstc 확장: stimecmp CSR을 직접 기록 (S-mode 타이머) */
        csr_write(CSR_STIMECMP, next_tval);
    } else {
        /* SBI 경로: S-mode는 mtimecmp에 직접 접근할 수 없어 SBI 호출 사용 */
        sbi_set_timer(next_tval);
    }
    return 0;
}

/* Sstc 확장이 있으면 SBI 없이 stimecmp CSR 직접 사용 */
static int riscv_clock_next_event_sstc(unsigned long delta,
                                       struct clock_event_device *ce)
{
    csr_write(CSR_STIMECMP, get_cycles64() + delta);
    return 0;
}

/* IPI 전송: ACLINT MSWI 또는 SBI 사용 */
static void riscv_send_ipi(const struct cpumask *mask)
{
    if (ipi_ops && ipi_ops->ipi_inject)
        ipi_ops->ipi_inject(mask);  /* ACLINT 직접 접근 */
    else
        sbi_send_ipi(mask);         /* SBI 경유 */
}

커스텀 확장과 Discovery

RISC-V의 가장 큰 특징은 모듈형 확장(extension) 시스템입니다. 표준 확장(M, A, F, D, C, V 등) 외에도 벤더별 커스텀 확장을 자유롭게 추가할 수 있으며, 커널은 부팅 시 하드웨어가 지원하는 확장을 감지하여 런타임에 최적화된 코드 경로를 선택합니다. ISA 문자열 파싱, riscv_hwprobe() syscall, AT_HWCAP 등 다양한 디스커버리 메커니즘이 존재합니다.

ISA 문자열과 /proc/cpuinfo

/* arch/riscv/kernel/cpu.c — /proc/cpuinfo 생성 */
/* DT의 riscv,isa 또는 riscv,isa-extensions 프로퍼티에서 파싱 */

/* 예시 /proc/cpuinfo 출력: */
/* processor    : 0                                */
/* hart         : 0                                */
/* isa          : rv64imafdc_zicntr_zicsr_zifencei  */
/*                _zihpm_zba_zbb_zbs_svadu          */
/* mmu          : sv39                             */

/* arch/riscv/kernel/cpufeature.c — ISA 문자열 파싱 */
static void riscv_fill_hwcap_from_isa_string(unsigned long *isa2hwcap)
{
    struct device_node *node;
    const char *isa;

    for_each_possible_cpu_node(node) {
        if (of_property_read_string(node, "riscv,isa-extensions", &isa))
            of_property_read_string(node, "riscv,isa", &isa);

        /* "rv64" 접두사 건너뛰기 */
        /* 단일 문자 확장(i,m,a,f,d,c,v) 파싱 */
        /* 멀티 문자 확장(_zba_zbb_zbs...) 파싱 */
        /* 벤더 확장(_xtheadba_xtheadbb...) 파싱 */
    }
}

riscv_isa_extension API

/* arch/riscv/include/asm/hwcap.h */
/* 확장 존재 여부를 비트맵으로 검사 */

/* 정적 키 기반 빠른 검사 (핫 패스용) */
static __always_inline bool
riscv_has_extension_likely(unsigned int ext)
{
    if (IS_ENABLED(CONFIG_RISCV_ALTERNATIVE))
        return __riscv_isa_extension_available(NULL, ext);
    return __riscv_isa_extension_available(riscv_isa, ext);
}

/* 사용 예시 */
if (riscv_has_extension_likely(RISCV_ISA_EXT_ZBB)) {
    /* Zbb (기본 비트 조작) 확장 사용 */
    count = __builtin_popcountl(val);  /* cpop 명령어 활용 */
} else {
    /* 소프트웨어 대체 구현 */
    count = hweight_long(val);
}

/* riscv_hwprobe() syscall — 유저 공간 디스커버리 */
/* struct riscv_hwprobe { __s64 key; __u64 value; }; */
/* RISCV_HWPROBE_KEY_IMA_EXT_0 → Zba, Zbb, Zbs 등 비트마스크 */
/* RISCV_HWPROBE_KEY_CPUPERF_0 → 마이크로아키텍처 성능 힌트 */

주요 표준 확장 목록

PMP (Physical Memory Protection)

PMP(Physical Memory Protection)는 RISC-V의 하드웨어 기반 물리 메모리(Physical Memory) 보호 메커니즘입니다. M-mode 펌웨어(OpenSBI)가 PMP 레지스터를 설정하여 S-mode(커널)와 U-mode(유저)의 물리 메모리 접근 범위를 제한합니다. PMP가 없으면 S-mode에서 전체 물리 메모리에 접근할 수 있어 보안상 위험합니다. PMP 엔트리는 pmpcfg(구성)과 pmpaddr(주소) CSR 쌍으로 구성됩니다.

PMP 엔트리 매칭 다이어그램

OpenSBI PMP 설정

/* OpenSBI: lib/sbi/sbi_hart.c — PMP 초기 설정 */
/* S-mode(커널)가 접근할 수 있는 메모리 영역 정의 */

/* PMP 설정 예시: */
/* PMP0: OpenSBI 펌웨어 영역 보호 (S-mode 접근 금지) */
/* PMP1: 나머지 전체 메모리 접근 허용 (S-mode RWX) */

static int sbi_hart_pmp_configure(struct sbi_scratch *scratch)
{
    /* PMP0: OpenSBI 펌웨어 영역을 S-mode에서 접근 불가로 설정 */
    unsigned long fw_start = scratch->fw_start;
    unsigned long fw_size  = scratch->fw_size;

    /* TOR 모드로 펌웨어 영역 보호 */
    pmp_set(0, 0, fw_start,
            PMP_A_TOR | PMP_L);            /* Locked, no access */
    pmp_set(1, PMP_R | PMP_W | PMP_X,
            fw_start + fw_size,
            PMP_A_TOR | PMP_L);            /* Locked, no RWX */

    /* PMP2: 나머지 전체 메모리를 S-mode에 RWX 허용 */
    pmp_set(2, PMP_R | PMP_W | PMP_X,
            0xFFFFFFFFFFFFFFFFUL,
            PMP_A_NAPOT);                  /* 전체 주소 공간 */

    return 0;
}

커널에서의 PMP 활용

/* arch/riscv/kernel/cpufeature.c — PMP 엔트리 수 감지 */
/* RISC-V 스펙: 최소 0개, 최대 64개 PMP 엔트리 지원 */

/* 커널은 PMP를 직접 설정하지 않음 (M-mode 전용 CSR) */
/* 대신 SBI를 통해 PMP 관련 정보를 조회 */

/* Smepmp (Machine-mode enhancement for PMP): */
/* - M-mode 코드의 실행 권한을 PMP로 제한 가능 */
/* - mseccfg CSR로 MML/MMWP/RLB 비트 제어 */
/* - MML=1: Machine Mode Lockdown — M-mode도 PMP 적용 */
/* - MMWP=1: 기본 거부 정책 (PMP 미매칭 시 M-mode도 거부) */
/* - RLB=1: Rule Locking Bypass (디버그용) */

/* ePMP (enhanced PMP) 지원 확인 */
if (sbi_probe_extension(SBI_EXT_FWFT)) {
    /* Firmware Feature 확장으로 Smepmp 상태 조회 */
}

H 확장 (하이퍼바이저(Hypervisor))

RISC-V H 확장(Hypervisor Extension)은 효율적인 하드웨어 가상화(Virtualization)를 지원합니다. HS-mode(Hypervisor-extended Supervisor)에서 하이퍼바이저가 동작하고, VS-mode(Virtual Supervisor)/VU-mode(Virtual User)에서 게스트 OS와 유저 프로그램이 실행됩니다. 2단계 주소 변환(VS-stage + G-stage)으로 게스트 물리 주소를 호스트 물리 주소로 변환하며, KVM이 이를 활용합니다.

2단계 주소 변환 다이어그램

VS-mode CSR 접근과 VM 진입/종료

/* arch/riscv/kvm/vcpu.c — KVM vCPU 실행 */
int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)
{
    struct kvm_run *run = vcpu->run;

    /* 게스트 CSR 복원 */
    kvm_riscv_vcpu_swap_in_guest_csrs(vcpu);

    /* G-stage 페이지 테이블 설정 */
    csr_write(CSR_HGATP, vcpu->arch.guest_context.hgatp);

    /* hstatus.SPV = 1 → sret 시 VS-mode로 진입 */
    csr_set(CSR_HSTATUS, HSTATUS_SPV);

    /* 게스트 레지스터 복원 후 sret → VM entry */
    __kvm_riscv_switch_to(&vcpu->arch);

    /* VM exit: 트랩이 HS-mode로 복귀 */
    unsigned long scause = csr_read(CSR_SCAUSE);
    unsigned long htval  = csr_read(CSR_HTVAL);

    /* htval: 게스트 물리 주소 (GPA) — 상위 비트 2만큼 시프트 */
    unsigned long gpa = htval << 2;

    /* exit 원인에 따라 처리 */
    switch (scause) {
    case EXC_VIRTUAL_INST_FAULT:
        kvm_riscv_vcpu_virtual_insn(vcpu, run, trap);
        break;
    case EXC_INST_GUEST_PAGE_FAULT:
    case EXC_LOAD_GUEST_PAGE_FAULT:
    case EXC_STORE_GUEST_PAGE_FAULT:
        kvm_riscv_vcpu_exit(vcpu, run, trap);
        break;
    }
    return 0;
}

hfence 명령어

/* 게스트 TLB 관리 명령어 */

/* hfence.vvma — VS-stage TLB 플러시 (현재 VMID) */
    hfence.vvma zero, zero          /* 전체 VS TLB 플러시 */
    hfence.vvma a0, zero             /* 특정 GVA의 VS TLB 플러시 */
    hfence.vvma zero, a1             /* 특정 게스트 ASID의 VS TLB */
    hfence.vvma a0, a1               /* GVA + 게스트 ASID */

/* hfence.gvma — G-stage TLB 플러시 (GPA→HPA 매핑) */
    hfence.gvma zero, zero          /* 전체 G-stage TLB 플러시 */
    hfence.gvma a0, zero             /* 특정 GPA의 G-stage TLB */
    hfence.gvma zero, a1             /* 특정 VMID의 G-stage TLB */
    hfence.gvma a0, a1               /* GPA + VMID */

/* hlv/hsv — HS-mode에서 게스트 메모리 직접 접근 */
    hlv.d   t0, (a0)                 /* 게스트 가상 주소에서 8바이트 로드 */
    hsv.d   t0, (a0)                 /* 게스트 가상 주소에 8바이트 저장 */
    /* hlv/hsv는 VS-stage + G-stage 변환을 모두 수행 */

CMO (Cache Management Operations)

RISC-V CMO(Cache Management Operations) 확장은 소프트웨어가 캐시를 명시적으로 관리할 수 있는 명령어를 제공합니다. Zicbom(Cache Block Management: clean/flush/inval)과 Zicboz(Cache Block Zero)로 구성되며, DMA 일관성 유지, 보안을 위한 메모리 제로화, 성능 최적화에 활용됩니다. 기존 RISC-V 기본 ISA에는 캐시 관리 명령어가 없어 벤더별 비표준 확장에 의존했으나, CMO 확장으로 표준화되었습니다.

CBO 명령어

/* Zicbom — Cache Block Management Operations */
/* 캐시 블록 크기는 구현체에 따라 다름 (보통 64바이트) */

/* cbo.clean — 캐시 라인을 메모리에 쓰기 (dirty → clean) */
    cbo.clean  (a0)                 /* a0 주소의 캐시 블록 clean */
    /* 용도: DMA 전송 전 더티 데이터 메모리 반영 */

/* cbo.flush — clean 후 무효화 (dirty → memory, then invalidate) */
    cbo.flush  (a0)                 /* a0 주소의 캐시 블록 flush */
    /* 용도: DMA 전송 후 수신 버퍼의 stale 데이터 제거 */

/* cbo.inval — 캐시 라인 무효화 (dirty 데이터 버림) */
    cbo.inval  (a0)                 /* a0 주소의 캐시 블록 invalidate */
    /* 주의: dirty 데이터가 버려짐 — 주로 DMA 수신 전 사용 */

/* Zicboz — Cache Block Zero */
    cbo.zero   (a0)                 /* a0 주소의 캐시 블록을 0으로 채움 */
    /* 용도: 페이지 초기화 (allocate 없이 직접 저장) */
    /* clear_page()에서 memset 대신 사용 → 성능 향상 */

/* 캐시 블록 크기 순회 루프 */
flush_cache_range:                /* a0=start, a1=end */
1:  cbo.flush (a0)
    add     a0, a0, a2             /* a2 = cbom_block_size */
    bltu    a0, a1, 1b
    ret

DMA 캐시 관리 시퀀스

/* arch/riscv/mm/dma-noncoherent.c — 비캐시 일관성 DMA 관리 */
void arch_sync_dma_for_device(phys_addr_t paddr, size_t size,
                              enum dma_data_direction dir)
{
    void *vaddr = phys_to_virt(paddr);

    switch (dir) {
    case DMA_TO_DEVICE:
        /* CPU → 디바이스: dirty 캐시를 메모리에 반영 */
        ALT_CMO_OP(clean, vaddr, size, riscv_cbom_block_size);
        break;
    case DMA_FROM_DEVICE:
        /* 디바이스 → CPU: stale 캐시 무효화 */
        ALT_CMO_OP(inval, vaddr, size, riscv_cbom_block_size);
        break;
    case DMA_BIDIRECTIONAL:
        /* 양방향: flush (clean + invalidate) */
        ALT_CMO_OP(flush, vaddr, size, riscv_cbom_block_size);
        break;
    }
}

/* ALT_CMO_OP 매크로: Zicbom이 없으면 대체 구현 사용 */
/* alternatives 메커니즘으로 부팅 시 CBO 명령어 패칭 */
/* riscv_cbom_block_size: DT cbom-block-size 프로퍼티에서 파싱 */

/* cbo.zero를 clear_page에 활용 */
void clear_page(void *page)
{
    if (riscv_has_extension_likely(RISCV_ISA_EXT_ZICBOZ)) {
        for (int i = 0; i < PAGE_SIZE; i += riscv_cboz_block_size)
            cbo_zero(page + i);
    } else {
        memset(page, 0, PAGE_SIZE);
    }
}

alternatives 패칭과 errata

RISC-V Linux 커널의 alternatives 프레임워크는 부팅 시 CPU 확장 지원 여부에 따라 코드를 동적으로 패칭합니다. x86의 alternatives와 유사한 개념으로, 기본(fallback) 코드와 최적화된 대체(alternative) 코드를 준비하고, 런타임에 하드웨어 기능이 감지되면 대체 코드로 교체합니다. 벤더별 errata 수정에도 동일한 메커니즘이 사용됩니다.

ALTERNATIVE 매크로

/* arch/riscv/include/asm/alternative-macros.h */
/* ALTERNATIVE(old_content, new_content, vendor_id, patch_id, enable) */

/* 예시: Zbb 확장이 있으면 최적화된 명령어 사용 */
static __always_inline int arch_fls(unsigned int x)
{
    int r;
    asm volatile(
        ALTERNATIVE(
            /* 기본 구현: 소프트웨어 FLS */
            "li %0, 32\n"               /* fallback: 루프 기반 */
            "beqz %1, 1f\n"
            "clz %0, %1\n"              /* pseudo: SW clz */
            "1:\n",
            /* Zbb 대체: 하드웨어 CLZ 명령어 */
            "clz %0, %1\n"              /* HW clz 명령어 */
            "neg %0, %0\n"
            "addi %0, %0, 32\n",
            0,                           /* vendor_id: 0 = 표준 */
            RISCV_ISA_EXT_ZBB,           /* patch_id */
            CONFIG_RISCV_ISA_ZBB)        /* Kconfig */
        : "=r"(r) : "r"(x));
    return r;
}

패칭 엔진

/* arch/riscv/kernel/alternative.c */
/* 부팅 시 __alt_start ~ __alt_end 섹션을 순회하며 패칭 */

struct alt_entry {
    void *old_ptr;       /* 원본 코드 주소 */
    void *alt_ptr;       /* 대체 코드 주소 */
    unsigned long vendor_id;  /* 0: 표준, >0: 벤더별 */
    unsigned int alt_len;    /* 대체 코드 길이 */
    unsigned int old_len;    /* 원본 코드 길이 (NOP 패딩용) */
};

void riscv_cpufeature_patch_func(struct alt_entry *begin,
                                struct alt_entry *end,
                                unsigned int stage)
{
    for (struct alt_entry *a = begin; a < end; a++) {
        if (!riscv_cpufeature_patch_check(a->vendor_id, a->alt_len))
            continue;

        /* 대체 코드를 원본 위치에 복사 */
        patch_text_nosync(a->old_ptr, a->alt_ptr, a->alt_len);

        /* 원본이 더 길면 나머지를 NOP으로 채움 */
        if (a->old_len > a->alt_len)
            patch_text_nosync(a->old_ptr + a->alt_len,
                             nops, a->old_len - a->alt_len);
    }

    /* 패칭 완료 후 I-cache 동기화 */
    local_flush_icache_all();
}

벤더 errata 패칭 (T-Head, SiFive)

/* arch/riscv/errata/thead/errata.c — T-Head 에라타 */
/* Alibaba T-Head C906/C910 CPU의 하드웨어 버그 수정 */

static bool errata_probe_cmo(unsigned int stage,
                             unsigned long arch_id,
                             unsigned long impid)
{
    /* T-Head C9xx는 표준 Zicbom 대신 자체 캐시 명령어 사용 */
    /* th.dcache.civa (clean+inval by VA) */
    /* th.dcache.iva  (inval by VA) */
    /* th.dcache.cva  (clean by VA) */
    if (arch_id == THEAD_VENDOR_ID &&
        impid == THEAD_IMPID_C9XX) {
        return true;  /* T-Head CMO 에라타 적용 */
    }
    return false;
}

/* arch/riscv/errata/sifive/errata.c — SiFive 에라타 */
/* SiFive U74 (FU740) 에라타: CIP-1200 */
/* 특정 조건에서 I-cache가 stale 데이터 반환 */
/* 수정: sfence.vma 전후 fence.i 삽입 */

static bool errata_probe_cip1200(unsigned int stage,
                                 unsigned long arch_id,
                                 unsigned long impid)
{
    if (arch_id != SIFIVE_VENDOR_ID)
        return false;
    /* U74 코어에서만 sfence.vma에 fence.i 추가 */
    return (impid == SIFIVE_IMPID_U74);
}

디버그 모듈과 Trigger

RISC-V Debug 스펙은 외부 디버거(JTAG/OpenOCD)와 자체 트리거(hardware breakpoint/watchpoint) 두 가지 디버그 메커니즘을 정의합니다. Debug Module(DM)은 하트를 정지시키고 레지스터/메모리를 검사하는 외부 인터페이스이며, Trigger Module은 주소/데이터 매칭 시 브레이크포인트/워치포인트를 생성합니다. Linux 커널은 Trigger Module을 perf와 ptrace를 통해 하드웨어 브레이크포인트로 노출합니다.

디버그 모듈 아키텍처

Trigger CSR 설정

/* arch/riscv/kernel/hw_breakpoint.c */
/* Trigger CSR을 사용한 하드웨어 브레이크포인트/워치포인트 */

/* Trigger 관련 CSR: */
/* tselect  — 활성 트리거 인덱스 선택 (0, 1, 2, ...) */
/* tdata1   — 트리거 타입 및 구성 (mcontrol/mcontrol6) */
/* tdata2   — 매칭 값 (주소 또는 데이터) */
/* tdata3   — 추가 매칭 (mhvalue, sselect 등) */
/* tinfo    — 지원하는 트리거 타입 비트마스크 (읽기 전용) */

static int riscv_install_hw_breakpoint(struct perf_event *bp)
{
    struct arch_hw_breakpoint *info = counter_arch_bp(bp);
    int idx = info->trigger_idx;

    /* 트리거 인덱스 선택 */
    csr_write(CSR_TSELECT, idx);

    /* tdata1: mcontrol6 타입 설정 */
    unsigned long tdata1 = 0;
    tdata1 |= MCONTROL6_TYPE;              /* Type 6 */
    tdata1 |= MCONTROL6_DMODE;             /* D-mode에서만 변경 가능 */

    if (info->type == HW_BREAKPOINT_X) {
        tdata1 |= MCONTROL6_EXECUTE;       /* 실행 브레이크포인트 */
    } else {
        if (info->type & HW_BREAKPOINT_R)
            tdata1 |= MCONTROL6_LOAD;      /* 읽기 워치포인트 */
        if (info->type & HW_BREAKPOINT_W)
            tdata1 |= MCONTROL6_STORE;     /* 쓰기 워치포인트 */
    }
    tdata1 |= MCONTROL6_S;                 /* S-mode에서 트리거 */
    tdata1 |= MCONTROL6_U;                 /* U-mode에서 트리거 */
    tdata1 |= MCONTROL6_ACTION_BKPT;       /* 브레이크포인트 예외 발생 */

    /* tdata2: 매칭할 주소 설정 */
    csr_write(CSR_TDATA2, info->address);
    /* tdata1: 구성 적용 (마지막에 써야 활성화) */
    csr_write(CSR_TDATA1, tdata1);

    return 0;
}

하드웨어 브레이크포인트 API

/* arch/riscv/kernel/hw_breakpoint.c — 커널 API */

/* 트리거 수 감지 (부팅 시) */
static int riscv_get_trigger_count(void)
{
    int count = 0;
    for (int i = 0; i < MAX_TRIGGERS; i++) {
        csr_write(CSR_TSELECT, i);
        if (csr_read(CSR_TSELECT) != i)
            break;  /* 지원하지 않는 인덱스 */
        unsigned long tinfo = csr_read(CSR_TINFO);
        if (tinfo & (TINFO_TYPE2 | TINFO_TYPE6))
            count++;  /* mcontrol 또는 mcontrol6 지원 */
    }
    return count;
}

/* 브레이크포인트 예외 핸들러 (scause=3) */
void do_trap_break(struct pt_regs *regs)
{
    /* 커널 KGDB 브레이크포인트 확인 */
    if (kgdb_handle_exception(regs))
        return;

    /* perf 하드웨어 브레이크포인트 확인 */
    if (riscv_hw_breakpoint_handler(regs))
        return;

    /* BUG()/WARN() 매크로의 ebreak 명령어 확인 */
    if (report_bug(regs->epc, regs) == BUG_TRAP_TYPE_WARN) {
        regs->epc += 4;  /* C 확장 시 2 */
        return;
    }

    /* 유저 공간 SIGTRAP */
    force_sig(SIGTRAP);
}

최신 RISC-V 동향 (v6.15~v7.0, 2025-2026)

RISC-V는 2025~2026년 기간 동안 가장 빠르게 확장된 아키텍처입니다. 신규 비준 확장의 커널 병합, 병렬 CPU 핫플러그(Hotplug), 제어 흐름 무결성(CFI / Integrity) 도입 등 현대 ISA가 갖춰야 할 핵심 기능이 대거 추가되었습니다.

Zicfiss / Zicfilp — RISC-V CFI 상세

Linux 7.0에 병합된 Zicfiss(Shadow Stack)와 Zicfilp(Indirect Branch Landing Pad)는 RISC-V의 제어 흐름 무결성을 하드웨어에서 강제하는 확장입니다. 두 확장은 RISC-V International이 v1.0으로 비준(ratified)한 표준 확장이며, x86 CET(Shadow Stack + IBT), ARM64 GCS/BTI와 동급의 기능을 제공합니다.

• Zicfiss(후진 엣지, Backward-Edge CFI): 일반 스택과 별개의 섀도 스택(Shadow Stack)을 유지하여 함수 ret 시 반환 주소를 검증합니다. 새 ssp(Shadow Stack Pointer) CSR과 sspush(반환 주소를 섀도 스택에 push), sspopchk(섀도 스택에서 pop 후 실제 반환 주소와 비교), ssrd(섀도 스택 읽기) 명령어가 추가됩니다. 호출 시 sspush가 x1/x5(ra/t5)의 반환 주소를 섀도 스택에 기록하고, ret 직전 sspopchk가 일치 여부를 확인하여 ROP(Return-Oriented Programming) 공격을 차단합니다. x86 CET SS, ARM64 GCS와 대응합니다.
• Zicfilp(전진 엣지, Forward-Edge CFI): 간접 분기(jalr) 타깃은 반드시 lpad(Landing Pad) 명령어에서 시작해야 합니다. lpad는 4바이트 정렬 + 예상 레이블(label) 검사를 수행하며, 정렬/레이블 불일치 시 불법 명령어 예외가 발생합니다. 단 rs1 = x1(ra) 또는 rs1 = x5(함수 반환)는 예외로 lpad 없이도 점프 가능하며, 이 경로는 Zicfiss 섀도 스택이 보호합니다. x86 CET IBT(ENDBR), ARM64 BTI와 대응합니다.
• 유저스페이스 사용: glibc 등 libc 런타임이 ELF .note.gnu.property 노트의 GNU_PROPERTY_RISCV_FEATURE_1_AND에 ZICFISS/ZICFILP 비트를 설정해 CFI 활성을 표시하면 커널이 태스크 생성 시 섀도 스택을 할당합니다. prctl(PR_GET_SHADOW_STACK_STATUS)로 현재 상태를 조회하고 PR_SET_SHADOW_STACK_STATUS로 활성/비활성을 제어합니다. 섀도 스택 영역은 map_shadow_stack() 시스템 콜(공통 syscall 번호 453)로 직접 매핑하며, SHADOW_STACK_SET_TOKEN/SHADOW_STACK_SET_MARKER 플래그로 복원 토큰과 상단 마커를 설정합니다.
• 커널 경로: 사용자 모드에서 커널로 진입할 때 ssp(Shadow Stack Pointer) CSR 값을 태스크(Task)의 CFI 상태(struct cfi_state)에 저장하고 커널 복귀 시 복원합니다. 커널 자체의 반환 주소 보호는 Zicfiss 섀도 스택이 아니라 별도의 커널 Shadow Call Stack(SCS, arch/riscv/include/asm/scs.h)으로 수행하며, Zicfilp의 lpad를 함수 진입점에 배치해 커널 내 JOP/ROP 방어를 강화합니다.

주요 하드웨어 현황

• SpacemiT K1: RVA22 + 벡터(v6.14), 저가형 개발 보드에 탑재되어 데스크톱 실사용 가능
• SG2042 / SG2044 (Sophon): 64코어 서버급, ACPI 부팅 경로 v6.19로 본격화
• T-Head Xuantie: xtheadvector 확장(v6.14 병합), 스마트폰급 SoC 활용
• Tenstorrent Blackhole: AI 가속기, v6.19에서 호스트 기초 지원
• SiFive P870/X280: 서버·AI 시장 겨냥, RVA23 프로파일 준수

커널 v6.13~v6.14 핵심 변경사항

v6.13~v6.14는 RISC-V의 보안 강화와 하드웨어 다양성 확대를 이끈 중요한 버전입니다.

v6.13 — 포인터 마스킹 확장 및 KVM 개선

Linux 6.13에서 RISC-V에 포인터 마스킹(Pointer Masking) 확장 3종이 추가되었습니다.

포인터 마스킹은 ARM64 TBI(Top-Byte Ignore), x86 LAM(Linear Address Masking)과 유사하게 포인터 상위 비트를 메타데이터 저장 공간으로 사용할 수 있게 합니다. ASAN/HWASAN 스타일의 태그 기반 메모리 안전성 도구 구현에 핵심적입니다.

또한 v6.13에서는 Zacas + Zabha 확장을 이용한 원자 연산 가속이 추가되었습니다. arch_cmpxchg()에서 XLEN 폭 연산은 Zacas(원자적 CAS)만 존재하면 LR/SC 루프 대신 단일 amocas 명령으로 컴파일되고, 바이트/하프워드처럼 XLEN보다 좁은 폭은 Zabha(바이트/하프워드 원자 연산) 확장이 함께 있어야 단일 원자 명령으로 처리됩니다.

/* arch/riscv/include/asm/cmpxchg.h — arch_cmpxchg() */
if (IS_ENABLED(CONFIG_RISCV_ISA_ZACAS) &&
    IS_ENABLED(CONFIG_TOOLCHAIN_HAS_ZACAS) &&
    riscv_has_extension_unlikely(RISCV_ISA_EXT_ZACAS)) {
    /* Zacas: 단일 원자 CAS 명령으로 교체 */
    __asm__ __volatile__ (
        "	.option push\n"
        "	.option arch, +zacas\n"
        "	amocas.d %0, %z2, %1\n"
        "	.option pop\n"
        : "+&r" (r), "+A" (*(p))
        : "rJ" (n)
        : "memory");
} else {
    /* Zacas가 없으면 LR/SC(원자 예약/조건부 저장) 루프로 폴백 */
}

부팅 시에는 riscv_spinlock_init()(arch/riscv/kernel/setup.c)이 Zabha + Zacas가 모두 감지되거나 Ziccrse가 감지되면 qspinlock을 선택하고, 어느 쪽도 없으면 CONFIG_RISCV_COMBO_SPINLOCKS 설정에 따라 티켓 스핀락(Ticket Spinlock)으로 전환합니다. qspinlock 슬로우 패스 자체는 아키텍처 공통 구현(kernel/locking/qspinlock.c)을 공유하고, RISC-V는 위 arch_cmpxchg() 원자 연산만 제공합니다.

KVM 개선으로 Svade/Svadu (Accessed/Dirty bit) 확장의 호스트·게스트 양쪽 지원이 추가되었습니다. Svadu가 있으면 하드웨어가 A/D 비트를 자동 갱신하여 OS의 페이지 폴트 오버헤드가 줄어듭니다. KVM은 게스트에 Svadu HWCAP을 노출하고 HGATP 설정 시 자동 활성화합니다.

v6.14 — T-Head XTheadVector 및 GhostWrite 완화

Linux 6.14에서 Alibaba T-Head 칩셋에서 사용하는 XTheadVector 확장이 메인라인에 병합되었습니다. 이 확장은 RISC-V Vector 0.7.1을 기반으로 하는 비표준 벡터 확장으로, 표준 V 확장과 혼용이 불가능합니다.

• 레지스터: 32개 벡터 레지스터 (v0~v31) + 6개 비특권 CSR 추가
• 커널 처리: RISCV_ISA_EXT_XTHEADVECTOR로 구분. 표준 V 확장과 동시 활성화 불가 (exclusive)
• 컨텍스트 스위치: arch/riscv/include/asm/vector.h에 T-Head 전용 저장/복원 루틴 추가
• 영향 보드: Sipeed Lichee Pi 4A (TH1520), BeagleV-Ahead 등

v6.14에서는 또한 SpacemiT K1 SoC(RISC-V 8코어, RV64GCVB)의 pinctrl 드라이버가 기본 활성화되어 Banana Pi BPI-F3 등 보드에서 데스크톱 리눅스 배포판 사용이 본격화되었습니다.

커널 6.14부터: XTheadVector 지원 + GhostWrite 완화, SpacemiT K1 기본 지원

v6.19 — Zalasr, Zilsd/Zclsd, Zicbop 사용자 공간(User Space) 노출

Linux 6.19에서 새로운 RISC-V 비준 확장 지원이 추가되었습니다.

또한 v6.19에서 보조 CPU 병렬 핫플러그가 RISC-V에 도입되었습니다. 기존에는 CPU를 순차적으로 부팅했지만, 이제 SBI HSM(Hart State Management) START 요청을 병렬로 발행하여 다수 코어 시스템(예: SG2042 64코어)의 부팅 시간이 대폭 단축됩니다.

/* arch/riscv/kernel/smpboot.c — 병렬 핫플러그 (v6.19+) */
static int __init smp_init_cpus(void)
{
    /* 모든 hart에 SBI HSM START 병렬 발행 */
    for_each_possible_cpu(cpu)
        riscv_sbi_hart_start(cpu);  /* 동기 대기 없음 */
    wait_for_completion(&smp_cpus_done);
    return 0;
}

커널 6.19부터: Zalasr/Zilsd/Zclsd 지원, Zicbop 유저스페이스 노출, 병렬 CPU 핫플러그

참고자료

• RISC-V 공식 사양서 — RISC-V ISA Specifications (Unprivileged/Privileged)
• RISC-V ISA 매뉴얼 GitHub 저장소 — riscv/riscv-isa-manual
• 커널 공식 문서 — Linux kernel RISC-V architecture documentation
• 커널 소스 — arch/riscv 디렉터리 (Bootlin Elixir)
• 커널 소스 — arch/riscv/kernel/entry.S 트랩 엔트리 (Bootlin Elixir)
• 커널 소스 — arch/riscv/kernel/head.S 부팅 엔트리 (Bootlin Elixir)
• LWN.net RISC-V 아키텍처 기사 모음 — LWN Kernel Index: RISC-V
• LWN.net — An introduction to RISC-V
• LWN.net — RISC-V kernel support improvements
• RISC-V SBI 사양 — RISC-V Supervisor Binary Interface specification
• OpenSBI 구현체 — RISC-V Open Source Supervisor Binary Interface
• RISC-V 벡터 확장 사양 — RISC-V "V" Vector Extension specification
• RISC-V PLIC 사양 — Platform-Level Interrupt Controller specification
• RISC-V 머신 모드 레퍼런스 — Machine-Level ISA (Five EmbedDev)