RISC-V 명령어셋 레퍼런스

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 번호만으로도 접근 가능 여부를 하드웨어가 즉시 판단할 수 있습니다.

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

주소 지정 모드

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

데이터 전송 명령어

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        /* 어셈블러가 위 보정을 자동 수행 */

산술 명령어

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

비교/분기 명령어

주요 의사 명령어(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)  */
/*  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레벨) 모드를 지원합니다. 리눅스 커널은 Sv48을 기본으로 사용하며, Sv57은 선택적으로 활성화됩니다.

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

RISC-V의 호출 규약(Calling Convention)은 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) 테이블

/* arch/riscv/kernel/traps.c */
static void (*excp_vect_table[])(struct pt_regs *) = {
    [EXC_INST_MISALIGNED]    = do_trap_insn_misaligned,
    [EXC_INST_ACCESS]        = do_trap_insn_fault,
    [EXC_INST_ILLEGAL]       = do_trap_insn_illegal,
    [EXC_BREAKPOINT]         = do_trap_break,
    [EXC_LOAD_ACCESS]        = do_trap_load_fault,
    [EXC_STORE_ACCESS]       = do_trap_store_fault,
    [EXC_SYSCALL]            = do_trap_ecall_u,
    [EXC_INST_PAGE_FAULT]    = do_page_fault,
    [EXC_LOAD_PAGE_FAULT]    = do_page_fault,
    [EXC_STORE_PAGE_FAULT]   = do_page_fault,
};

void do_trap_unknown(struct pt_regs *regs)
{
    unsigned long cause = regs->cause;
    if (cause < ARRAY_SIZE(excp_vect_table) && excp_vect_table[cause])
        excp_vect_table[cause](regs);
    else
        die(regs, "unhandled exception");
}

scause 예외/인터럽트 코드

커널 어셈블리 실전 예제

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

시스템 콜 진입 (entry.S)

/* arch/riscv/kernel/entry.S — 시스템 콜 처리 */
/* 유저 모드에서 ecall 실행 시 scause=8로 트랩 발생 */
handle_syscall:
    /* sepc는 ecall 명령어를 가리킴 → 다음 명령어로 이동 */
    addi    a0, a0, 4              /* sepc += 4 (ecall 다음) */
    REG_S   a0, PT_EPC(sp)         /* 수정된 sepc 저장 */

    /* syscall 번호 확인 (a7에 있음) */
    li      t0, __NR_syscalls       /* 최대 syscall 번호 */
    bgeu    a7, t0, .Lillegal_syscall

    /* syscall 테이블에서 핸들러 조회 */
    la      t0, sys_call_table
    slli    t1, a7, 3              /* t1 = a7 * 8 (포인터 크기) */
    add     t0, t0, t1
    ld      t0, 0(t0)              /* 핸들러 함수 포인터 */

    /* a0-a5에 syscall 인자가 이미 설정됨 */
    jalr    t0                     /* 핸들러 호출 */
    REG_S   a0, PT_A0(sp)          /* 반환값 저장 */

컨텍스트 스위치 (__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 */
static int riscv_clock_next_event(unsigned long delta,
                                  struct clock_event_device *ce)
{
    /* SBI를 통해 타이머 설정 (S-mode에서 mtimecmp 직접 접근 불가) */
    sbi_set_timer(get_cycles64() + delta);
    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 공식 사양서 — 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)

관련 문서