From 3ed496ec0187651bae629924c81077b6f073685f Mon Sep 17 00:00:00 2001
From: panxiakai <13212017962@163.com>
Date: Tue, 1 Nov 2022 10:44:24 +0800
Subject: [PATCH] kvm-mem-virt-impl: v1
---
articles/20221011-riscv-kvm-mem-virt-impl.md | 936 ++++++++++++++++++
.../images/riscv-kvm/vm-impl/gstage-at.png | Bin 0 -> 39305 bytes
.../mermaid-riscv-kvm-mem-virt-impl-1.png | Bin 0 -> 12205 bytes
.../mermaid-riscv-kvm-mem-virt-impl-2.png | Bin 0 -> 83580 bytes
4 files changed, 936 insertions(+)
create mode 100644 articles/20221011-riscv-kvm-mem-virt-impl.md
create mode 100644 articles/images/riscv-kvm/vm-impl/gstage-at.png
create mode 100644 articles/images/riscv-kvm/vm-impl/mermaid-riscv-kvm-mem-virt-impl-1.png
create mode 100644 articles/images/riscv-kvm/vm-impl/mermaid-riscv-kvm-mem-virt-impl-2.png
diff --git a/articles/20221011-riscv-kvm-mem-virt-impl.md b/articles/20221011-riscv-kvm-mem-virt-impl.md
new file mode 100644
index 0000000..13c34e5
--- /dev/null
+++ b/articles/20221011-riscv-kvm-mem-virt-impl.md
@@ -0,0 +1,936 @@
+> Corrector: [TinyCorrect](https://gitee.com/tinylab/tinycorrect) v0.1 - [spaces images urls]
+> Author: XiakaiPan <13212017962@163.com>
+> Date: 2022/10/11
+> Revisor: walimis, Falcon
+> Project: [RISC-V Linux 内核剖析](https://gitee.com/tinylab/riscv-linux)
+> Proposal: [RISC-V 虚拟化技术调研与分析](https://gitee.com/tinylab/riscv-linux/issues/I5E4VB)
+> Sponsor: PLCT Lab, ISCAS
+
+# RISC 内存虚拟化在 KVM 及 kvmtool 中的实现
+
+## 前言
+
+在 RISC-V 特权指令级中，H 扩展规定了实现虚拟化支持所需的一系列 CSR、指令和机制，[前文][3] 在指令集层面就内存虚拟化的相关机制进行了分析，在此基础之上，本文将讨论 KVM 中关于这一系列机制的具体实现。
+
+## 软件版本
+
+| Software | commit ID or version No. | Link |
+|--------------|------------------------------------------|------------------------------------|
+| Linux Kernel | 5.19-rc5 | https://www.kernel.org/ |
+| kvmtool | 6a1f699108e5c2a280d7cd1f1ae4816b8250a29f | https://github.com/kvmtool/kvmtool |
+
+## KVM 中的 G-Stage 地址转换实现
+
+KVM 对外提供了用于创建设备的接口 `kvm_dev_ioctl`，kvmtool 之类的外部虚拟机管理程序通过调用 KVM 提供的对应接口创建虚拟机。KVM 本身则以 RISC-V 特权指令集为标准，实现了 RISC-V 的虚拟化机制。RISC-V 将 Guest 虚拟地址转换为 Host 的物理地址的这一过程划分为两个阶段，即 VS-Stage 和 G-Stage，其中 VS-Stage 与常见的支持 M/S/U 三种模式的机器的地址转换机制一致，而 G-Stage 由于需要考虑 Hypervisor 对多个虚拟机的地址空间的分配，所以需要额外引入其他机制对上述分配进行管理，这也正是虚拟化实现中需要特别考虑的地方。而 KVM 对于 RISC-V 虚拟化的支持，相较于其他架构的实现，就体现在实现了一套 RISC-V 标准的虚拟机创建与管理机制。
+
+本节将对 KVM 中与 G-Stage 地址转换相关的代码进行分析。创建 KVM 虚拟机需要调用 `virt/kvm/kvm_main.c/kvm_create_vm` 函数，该函数内部则是通过 `arch/riscv/kvm/vcpu_exit.c/kvm_arch_init_vm` 来做架构初始化的，初始化的过程就是调用对应函数为虚拟机申请地址空间、初始化 vmid (Virtual Machine InDex)、初始化 Guest 计时器。下面将分析逐个分析与虚拟机内存管理相关的内存申请、CSR 修改、页缺陷处理、HFENCE 指令。
+
+
+
+### 地址定义
+
+在 KVM 的 RISC-V 虚拟化实现里，将分别使用 GVA, GPA 表示 VM 中的虚拟地址、物理地址，使用 HVA，HPA 表示 Host 中的虚拟地址、物理地址，使用 GFN 和 HFN 表示 Guest 和 Host 当前地址所在的物理页的页号，如下所示：
+
+```cpp
+/*
+ * Address types:
+ *
+ * gva - guest virtual address
+ * gpa - guest physical address
+ * gfn - guest frame number
+ * hva - host virtual address
+ * hpa - host physical address
+ * hfn - host frame number
+ */
+
+typedef unsigned long gva_t;
+typedef u64 gpa_t;
+typedef u64 gfn_t;
+
+#define GPA_INVALID (~(gpa_t)0)
+
+typedef unsigned long hva_t;
+typedef u64 hpa_t;
+typedef u64 hfn_t;
+```
+
+### 为虚拟机申请内存
+
+`arch/riscv/kvm/vm.c` 的 `kvm_arch_init_vm` 函数调用 `arch/riscv/kvm/mmu.c` 中的 `kvm_riscv_gstage_alloc_pgd(struct kvm *kvm)` 函数为虚拟机申请内存，具体来说是将被 Hypervisor 做分页管理的内存空间分配（ALLOcate）给虚拟机，表现为返回给 KVM 虚拟机一个页目录（PaGe Directory）。这一过程发生在 Hypervisor 的内存管理即 G-Stage 地址转换过程中。代码实现如下：
+
+```cpp
+// arch/riscv/kvm/mmu.c: line 712
+
+int kvm_riscv_gstage_alloc_pgd(struct kvm *kvm)
+{
+ struct page *pgd_page;
+ // 是否已经为 VM 分配了目录页号
+ if (kvm->arch.pgd != NULL) {
+ kvm_err("kvm_arch already initialized?\n");
+ return -EINVAL;
+ }
+ // 分配
+ pgd_page = alloc_pages(GFP_KERNEL | __GFP_ZERO,
+ get_order(gstage_pgd_size));
+ if (!pgd_page)
+ return -ENOMEM;
+ kvm->arch.pgd = page_to_virt(pgd_page);
+ kvm->arch.pgd_phys = page_to_phys(pgd_page);
+
+ return 0;
+}
+```
+
+其中 `alloc_pages` 函数中用到的参数相关的宏定义如下：
+
+```cpp
+// include/linux/gfp_types.h: line 333
+#define GFP_KERNEL (__GFP_RECLAIM | __GFP_IO | __GFP_FS)
+// include/linux/gfp_types.h: line 249
+#define __GFP_ZERO ((__force gfp_t)___GFP_ZERO)
+
+// arch/riscv/include/asm/csr.h: line 139
+#define HGATP_PAGE_SHIFT 12
+// include/linux/gfp_types.h: line 32
+#define gstage_pgd_xbits 2
+#define gstage_pgd_size (1UL << (HGATP_PAGE_SHIFT + gstage_pgd_xbits))
+```
+
+`alloc_pages` 函数定义如下：
+
+```cpp
+// include/linux/gfp.h: line 275
+static inline struct page *alloc_pages(gfp_t gfp_mask, unsigned int order)
+{
+ return alloc_pages_node(numa_node_id(), gfp_mask, order);
+}
+
+// include/linux/gfp.h: line 260
+/*
+ * Allocate pages, preferring the node given as nid. When nid == NUMA_NO_NODE,
+ * prefer the current CPU's closest node. Otherwise node must be valid and
+ * online.
+ */
+static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
+ unsigned int order)
+{
+ if (nid == NUMA_NO_NODE)
+ nid = numa_mem_id();
+
+ return __alloc_pages_node(nid, gfp_mask, order);
+}
+
+// include/linux/gfp.h: line 237
+/*
+ * Allocate pages, preferring the node given as nid. The node must be valid and
+ * online. For more general interface, see alloc_pages_node().
+ */
+static inline struct page *
+__alloc_pages_node(int nid, gfp_t gfp_mask, unsigned int order)
+{
+ VM_BUG_ON(nid < 0 || nid >= MAX_NUMNODES);
+ VM_WARN_ON((gfp_mask & __GFP_THISNODE) && !node_online(nid));
+
+ return __alloc_pages(gfp_mask, order, nid, NULL);
+}
+```
+
+最终执行页分配的函数是 `__alloc_pages`，该函数是 Linux OS 的 Buddy 内存管理系统的核心函数之一，其定义如下。以下关于该函数的分析以及对应的 Linux Buddy System 的解读参考自 [此文][007]。
+
+Linux 中的内存管理从大到小可以分为 node、zone、page 三个级别。其中 page（页）是分页内存机制和底层内存分配的最小单元，大小为 4K，物理页的编号叫做 pfn（page frame number）。
+
+```mermaid
+flowchart
+
+subgraph node0
+
+subgraph zone0
+
+subgraph page00
+end
+page01
+page0N[...]
+end
+
+subgraph zone1
+subgraph page10
+end
+page11
+page1N[...]
+end
+
+zoneN[...]
+
+end
+```
+
+（[下载由 Mermaid 生成的 PNG 图片][008]）
+
+伙伴内存系统（Buddy System）是对物理内存进行分配的算法，它的基本管理单位是区域（zone），最小分配粒度是页面（page）。但伙伴系统本身并不直接管理页帧，而是管理由多个页帧组成的页块（pageblock），一个 n 阶（order）的页块包含了 $2^n$ 个页帧，n 的大小为 0 到 10。伙伴系统的所有分配接口最终都会使用、\_\_alloc_pages 这个函数来进行分配。
+
+```cpp
+// mm/page_alloc.c: line 5513
+/*
+ * This is the 'heart' of the zoned buddy allocator.
+ */
+struct page *__alloc_pages(gfp_t gfp, unsigned int order, int preferred_nid,
+ nodemask_t *nodemask)
+{
+ struct page *page;
+
+ /* 页分配之前的准备工作，此处代码略去 */
+ /* Preparation code, omitted here */
+ // ...
+
+ /* 先从 freelist 中申请内存 */
+ /* First allocation attempt */
+ page = get_page_from_freelist(alloc_gfp, order, alloc_flags, &ac);
+ if (likely(page))
+ goto out;
+
+ // ...
+
+ /* 如果从 freelist 中申请失败，则需要在内存回收后进行分配，即 slow path */
+ page = __alloc_pages_slowpath(alloc_gfp, order, &ac);
+
+out:
+
+ // ...
+
+ return page;
+}
+```
+
+### 释放虚拟机内存
+
+与虚拟机的内存申请相似，KVM 释放内存也是通过调用 Linux 的 Buddy System 的内存释放 API 来实现的，具体来说 `arch/riscv/kvm/mmu.c/kvm_riscv_gstage_free_pgd()` 函数调用 `mm/page_alloc.c` 中的 `free_pages()` 函数释放对应虚拟机的内存。
+
+```cpp
+// arch/riscv/kvm/mmu.c: line 731
+void kvm_riscv_gstage_free_pgd(struct kvm *kvm)
+{
+ void *pgd = NULL;
+
+ spin_lock(&kvm->mmu_lock);
+ if (kvm->arch.pgd) {
+ gstage_unmap_range(kvm, 0UL, gstage_gpa_size, false);
+ pgd = READ_ONCE(kvm->arch.pgd);
+ kvm->arch.pgd = NULL;
+ kvm->arch.pgd_phys = 0;
+ }
+ spin_unlock(&kvm->mmu_lock);
+
+ if (pgd)
+ free_pages((unsigned long)pgd, get_order(gstage_pgd_size));
+}
+```
+
+Buddy System 释放内存的 API 调用如下方代码所示：
+
+```cpp
+// mm/page_alloc.c: 5641
+void free_pages(unsigned long addr, unsigned int order)
+{
+ if (addr != 0) {
+ VM_BUG_ON(!virt_addr_valid((void *)addr));
+ __free_pages(virt_to_page((void *)addr), order);
+ }
+}
+
+// mm/page_alloc.c: 5631
+void __free_pages(struct page *page, unsigned int order)
+{
+ if (put_page_testzero(page))
+ free_the_page(page, order);
+ else if (!PageHead(page))
+ while (order-- > 0)
+ free_the_page(page + (1 << order), order);
+}
+
+// mm/page_alloc.c: 764
+static inline void free_the_page(struct page *page, unsigned int order)
+{
+ if (pcp_allowed_order(order)) /* Via pcp? */
+ free_unref_page(page, order);
+ else
+ __free_pages_ok(page, order, FPI_NONE);
+}
+```
+
+### G-Stage Page Fault
+
+G-Stage 的页错误处理函数定义在 `arch/riscv/kvm/vcpu_exit.c` 中，定义如下。其中涉及的 MMIO 处理函数 `kvm_riscv_vcpu_mmio_load`，`kvm_riscv_vcpu_mmio_store` 此处不予讨论，下面分析如何通过调用 `kvm_riscv_gstage_map` 函数实现 G-Stage 的地址映射。
+
+```cpp
+// arch/riscv/kvm/vcpu_exit.c: line 12
+static int gstage_page_fault(struct kvm_vcpu *vcpu, struct kvm_run *run,
+ struct kvm_cpu_trap *trap)
+{
+ struct kvm_memory_slot *memslot;
+ unsigned long hva, fault_addr;
+ bool writable;
+ gfn_t gfn;
+ int ret;
+
+ // 从 trap 信息中获取页错误的地址 gpa (Guest Physical Address)
+ // get page fault address from trap information
+ fault_addr = (trap->htval << 2) | (trap->stval & 0x3);
+
+ // 将发生错误的地址先转换为 Guest 页号（Guest Frame Number）、再转换为可以在 hypervisor 中进行处理的 hva（Hypervisor Virtual Address）
+ gfn = fault_addr >> PAGE_SHIFT;
+ memslot = gfn_to_memslot(vcpu->kvm, gfn);
+ // 返回 gfn 对应的 hva 及其读写属性
+ // Return the hva of a @gfn and the R/W attribute if possible
+ hva = gfn_to_hva_memslot_prot(memslot, gfn, &writable);
+
+ // 依据 scause CSR 的值判定当前的 page fault 是何类型（Load/Store）并进行相应处理
+ if (kvm_is_error_hva(hva) ||
+ (trap->scause == EXC_STORE_GUEST_PAGE_FAULT && !writable)) {
+ switch (trap->scause) {
+ case EXC_LOAD_GUEST_PAGE_FAULT:
+ return kvm_riscv_vcpu_mmio_load(vcpu, run,
+ fault_addr,
+ trap->htinst);
+ case EXC_STORE_GUEST_PAGE_FAULT:
+ return kvm_riscv_vcpu_mmio_store(vcpu, run,
+ fault_addr,
+ trap->htinst);
+ default:
+ return -EOPNOTSUPP;
+ };
+ }
+
+ // 进行 G-Stage 的地址映射
+ ret = kvm_riscv_gstage_map(vcpu, memslot, fault_addr, hva,
+ (trap->scause == EXC_STORE_GUEST_PAGE_FAULT) ? true : false);
+ if (ret < 0)
+ return ret;
+
+ return 1;
+}
+```
+
+传入的参数中 `trap` 保存了此次 page fault 的具体信息，其定义如下。其中 `sepc`, `scause`, `stval` 是复用了非虚拟化时的 S-Mode CSR，而 `htval` 和 `htinst` 这两个 CSR 则是 H 扩展中为了支持 G-Stage 而添加的。
+
+```cpp
+// arch/riscv/include/asm/kvm_host.h
+struct kvm_cpu_trap {
+ unsigned long sepc;
+ unsigned long scause;
+ unsigned long stval;
+ unsigned long htval;
+ unsigned long htinst;
+};
+```
+
+`kvm_riscv_gstage_map` 函数通过如下三个部分实现了地址映射。
+
+第一部分是 `mmap_read_lock(current->mm);` 和 `mmap_read_unlock(current->mm);` 之间的代码，这部分通过 hva 初始化 vma（Virtual Memory Area，虚拟内存区域，用于表示具有特定 page-fault 处理方式的 Virtual Memory Space 的任意部分，参见 `include/linux/mm_types.h` 403 行定义）最终确定 gfn 的值。
+
+第二部分是调用 `gfn_to_pfn_prot` 用 gfn 的值初始化 hfn 的值。
+
+第三部分则是 `spin_lock(&kvm->mmu_lock);` 和 `spin_unlock(&kvm->mmu_lock);` 之间的代码段，用于更新 MMU：如果此次 page-fault 是要求无效化特定存储项的，则跳转到 `out_unlock` 部分设置并清除 hfn 项，否则的话将会根据此次 page-fault 对应页帧的可写状态调用 `gstage_map_page` 函数对 gpa 和 hpa（代码中即为 `hfn << PAGE_SHIFT`）进行映射。
+
+```cpp
+// arch/riscv/kvm/mmu.c: line 617
+int kvm_riscv_gstage_map(struct kvm_vcpu *vcpu,
+ struct kvm_memory_slot *memslot,
+ gpa_t gpa, unsigned long hva, bool is_write)
+{
+ int ret;
+ kvm_pfn_t hfn;
+ bool writable;
+ short vma_pageshift;
+ gfn_t gfn = gpa >> PAGE_SHIFT;
+ struct vm_area_struct *vma;
+ struct kvm *kvm = vcpu->kvm;
+ struct kvm_mmu_memory_cache *pcache = &vcpu->arch.mmu_page_cache;
+ bool logging = (memslot->dirty_bitmap &&
+ !(memslot->flags & KVM_MEM_READONLY)) ? true : false;
+ unsigned long vma_pagesize, mmu_seq;
+
+ mmap_read_lock(current->mm);
+
+ vma = find_vma_intersection(current->mm, hva, hva + 1);
+ if (unlikely(!vma)) {
+ kvm_err("Failed to find VMA for hva 0x%lx\n", hva);
+ mmap_read_unlock(current->mm);
+ return -EFAULT;
+ }
+
+ if (is_vm_hugetlb_page(vma))
+ vma_pageshift = huge_page_shift(hstate_vma(vma));
+ else
+ vma_pageshift = PAGE_SHIFT;
+ vma_pagesize = 1ULL << vma_pageshift;
+ if (logging || (vma->vm_flags & VM_PFNMAP))
+ vma_pagesize = PAGE_SIZE;
+
+ if (vma_pagesize == PMD_SIZE || vma_pagesize == PGDIR_SIZE)
+ gfn = (gpa & huge_page_mask(hstate_vma(vma))) >> PAGE_SHIFT;
+
+ mmap_read_unlock(current->mm);
+
+ if (vma_pagesize != PGDIR_SIZE &&
+ vma_pagesize != PMD_SIZE &&
+ vma_pagesize != PAGE_SIZE) {
+ kvm_err("Invalid VMA page size 0x%lx\n", vma_pagesize);
+ return -EFAULT;
+ }
+
+ /* We need minimum second+third level pages */
+ ret = kvm_mmu_topup_memory_cache(pcache, gstage_pgd_levels);
+ if (ret) {
+ kvm_err("Failed to topup G-stage cache\n");
+ return ret;
+ }
+
+ mmu_seq = kvm->mmu_invalidate_seq;
+
+ hfn = gfn_to_pfn_prot(kvm, gfn, is_write, &writable);
+ if (hfn == KVM_PFN_ERR_HWPOISON) {
+ send_sig_mceerr(BUS_MCEERR_AR, (void __user *)hva,
+ vma_pageshift, current);
+ return 0;
+ }
+ if (is_error_noslot_pfn(hfn))
+ return -EFAULT;
+
+ /*
+ * If logging is active then we allow writable pages only
+ * for write faults.
+ */
+ if (logging && !is_write)
+ writable = false;
+
+ spin_lock(&kvm->mmu_lock);
+
+ if (mmu_invalidate_retry(kvm, mmu_seq))
+ goto out_unlock;
+
+ if (writable) {
+ kvm_set_pfn_dirty(hfn);
+ mark_page_dirty(kvm, gfn);
+ ret = gstage_map_page(kvm, pcache, gpa, hfn << PAGE_SHIFT,
+ vma_pagesize, false, true);
+ } else {
+ ret = gstage_map_page(kvm, pcache, gpa, hfn << PAGE_SHIFT,
+ vma_pagesize, true, true);
+ }
+
+ if (ret)
+ kvm_err("Failed to map in G-stage\n");
+
+out_unlock:
+ spin_unlock(&kvm->mmu_lock);
+ kvm_set_pfn_accessed(hfn);
+ kvm_release_pfn_clean(hfn);
+ return ret;
+}
+```
+
+下面分析实现 gstage page-fault 处理的核心函数 `gstage_map_page`，其代码实现如下：
+
+```cpp
+// arch/riscv/kvm/mmu.c: line 177
+static int gstage_map_page(struct kvm *kvm,
+ struct kvm_mmu_memory_cache *pcache,
+ gpa_t gpa, phys_addr_t hpa,
+ unsigned long page_size,
+ bool page_rdonly, bool page_exec)
+{
+ int ret;
+ u32 level = 0;
+ pte_t new_pte;
+ pgprot_t prot;
+
+ // 根据 page_size 确定页所在层级（level），如果没有对应大小的页，则返回非 0 值
+ ret = gstage_page_size_to_level(page_size, &level);
+ if (ret)
+ return ret;
+
+ /*
+ * A RISC-V implementation can choose to either:
+ * 1) Update 'A' and 'D' PTE bits in hardware
+ * 2) Generate page fault when 'A' and/or 'D' bits are not set
+ * PTE so that software can update these bits.
+ *
+ * We support both options mentioned above. To achieve this, we
+ * always set 'A' and 'D' PTE bits at time of creating G-stage
+ * mapping. To support KVM dirty page logging with both options
+ * mentioned above, we will write-protect G-stage PTEs to track
+ * dirty pages.
+ */
+
+ /* 基于 RISC-V 指令集手册的 PTE 更新机制的实现可以有两种选择，
+ * 即在硬件中更新页表项（PTE）的 A（Access）/D（Dirty）位，
+ * 或默认 PTE 的 A/D 位不设置，当访问未初始化的 PTE 时产生 page-fault
+ * 从而使软件更新上述标志位。
+ *
+ * KVM 的实现中同时支持了上述两种机制：在进行 G-Stage 地址映射时就初始化
+ * 对应标志位，同时通过对 G-Stage PTEs 的写保护达成了软件层面的脏页追踪机制。
+ */
+
+ // 获取要执行操作的页的访问权限
+ if (page_exec) {
+ if (page_rdonly)
+ prot = PAGE_READ_EXEC;
+ else
+ prot = PAGE_WRITE_EXEC;
+ } else {
+ if (page_rdonly)
+ prot = PAGE_READ;
+ else
+ prot = PAGE_WRITE;
+ }
+ // 设置 hpa 对应页的权限位并标记为 dirty
+ new_pte = pfn_pte(PFN_DOWN(hpa), prot);
+ new_pte = pte_mkdirty(new_pte);
+
+ // 设置此次 page-fault 处理的页的内容
+ return gstage_set_pte(kvm, level, pcache, gpa, &new_pte);
+}
+```
+
+在 `gstage_set_pte` 内部，逐级遍历 hypervisor 的页表，直至到达制定 level 的页表，之后对其进行操作（赋值、视是否为叶子结点刷新 TLB）：
+
+```cpp
+// arch/riscv/kvm/mmu.c: line 137
+static int gstage_set_pte(struct kvm *kvm, u32 level,
+ struct kvm_mmu_memory_cache *pcache,
+ gpa_t addr, const pte_t *new_pte)
+{
+ u32 current_level = gstage_pgd_levels - 1;
+ pte_t *next_ptep = (pte_t *)kvm->arch.pgd;
+ pte_t *ptep = &next_ptep[gstage_pte_index(addr, current_level)];
+
+ if (current_level < level)
+ return -EINVAL;
+
+ while (current_level != level) {
+ if (gstage_pte_leaf(ptep))
+ return -EEXIST;
+
+ // 若当前页表项无效，则根据 pcache 的内容有效性选择申请页表项（kvm_mmu_memory_cache_alloc）或直接返回错误代码
+ if (!pte_val(*ptep)) {
+ if (!pcache)
+ return -ENOMEM;
+ next_ptep = kvm_mmu_memory_cache_alloc(pcache);
+ if (!next_ptep)
+ return -ENOMEM;
+ *ptep = pfn_pte(PFN_DOWN(__pa(next_ptep)),
+ __pgprot(_PAGE_TABLE));
+ } else {
+ if (gstage_pte_leaf(ptep))
+ return -EEXIST;
+ next_ptep = (pte_t *)gstage_pte_page_vaddr(*ptep);
+ }
+
+ current_level--;
+ ptep = &next_ptep[gstage_pte_index(addr, current_level)];
+ }
+
+ // 为找到的页表项赋值（保存之前设置的权限位和脏页标志位）
+ *ptep = *new_pte;
+ // 倘若为叶子页表，刷新 TLB 对应项
+ if (gstage_pte_leaf(ptep))
+ gstage_remote_tlb_flush(kvm, current_level, addr);
+
+ return 0;
+}
+```
+
+其中，逐级遍历找到下一级的页表项是通过交替更新 next_ptep 和 ptep 实现的，next_ptep 首先初始化为 page directory 即根页表，之后通过 `gstage_pte_index` 函数获得要操作的地址在当前层级页内的页表项索引，最终获得对应的当前层级的页表项。
+
+```cpp
+// arch/riscv/kvm/mmu.c: line 42
+static inline unsigned long gstage_pte_index(gpa_t addr, u32 level)
+{
+ unsigned long mask;
+ unsigned long shift = HGATP_PAGE_SHIFT + (gstage_index_bits * level);
+
+ if (level == (gstage_pgd_levels - 1))
+ mask = (PTRS_PER_PTE * (1UL << gstage_pgd_xbits)) - 1;
+ else
+ mask = PTRS_PER_PTE - 1;
+
+ return (addr >> shift) & mask;
+}
+```
+
+处理一个虚拟地址对应的 page-fault 意味着要更新其对应的 TLB 项，KVM 内部实现了内存操作的扩展指令集中的 `hfence.gvma`，该指令有 rs1 和 rs2 两个源操作数，分别指定了 Guest Address 和上述地址对应的 Guest 所在的 VM 的 ID（Index）。H 扩展相关的指令在 KVM 中的实现将在 [后续小节][1] 进行分析。
+
+```cpp
+// arch/riscv/kvm/mmu.c: line 126
+static void gstage_remote_tlb_flush(struct kvm *kvm, u32 level, gpa_t addr)
+{
+ unsigned long order = PAGE_SHIFT;
+
+ if (gstage_level_to_page_order(level, &order))
+ return;
+ addr &= ~(BIT(order) - 1);
+
+ kvm_riscv_hfence_gvma_vmid_gpa(kvm, -1UL, 0, addr, BIT(order), order);
+}
+```
+
+### HGATP 更新
+
+`hgatp` 的结构及其功能参见 [内存虚拟化一文][2] 对应章节，区别于 `satp` 和 `vsatp` 中由 `ASID` 来保存 Hypervisor/Supervisor 和 Guest 中的地址空间的索引值，`hgatp` 对应区域规定为 `VMID`，用于保存虚拟机的索引值。
+
+下面将结合 KVM 中 `hgatp` 的更新函数的具体实现及其调用，详细分析该 CSR 的功能。
+
+`kvm_riscv_gstage_update_hgatp` 函数定义在 `mmu.c` 中：
+
+```cpp
+// arch/riscv/kvm/mmu.c: line 748
+void kvm_riscv_gstage_update_hgatp(struct kvm_vcpu *vcpu)
+{
+ // 设置当前地址系统（SV32，SV39，etc.）对应的 hgatp 初始值
+ unsigned long hgatp = gstage_mode;
+ // 获取指向当前 vcpu 的架构信息的指针
+ struct kvm_arch *k = &vcpu->kvm->arch;
+
+ // 设置 hgatp.VMID 位
+ hgatp |= (READ_ONCE(k->vmid.vmid) << HGATP_VMID_SHIFT) &
+ HGATP_VMID_MASK;
+ // 设置 hgatp.PPN 位
+ hgatp |= (k->pgd_phys >> PAGE_SHIFT) & HGATP_PPN;
+
+ // 更新 hgatp 的值
+ csr_write(CSR_HGATP, hgatp);
+
+ // 若当前 vmid 无效，使用 hfence.gvma 指令刷新全部 TLB 的项
+ if (!kvm_riscv_gstage_vmid_bits())
+ kvm_riscv_local_hfence_gvma_all();
+}
+```
+
+如果为 64 位机器默认使用 SV39 的地址系统，否则若为 32 位机器则默认使用 SV32 的地址系统。
+
+```cpp
+#ifdef CONFIG_64BIT
+static unsigned long gstage_mode = (HGATP_MODE_SV39X4 << HGATP_MODE_SHIFT);
+static unsigned long gstage_pgd_levels = 3;
+#define gstage_index_bits 9
+#else
+static unsigned long gstage_mode = (HGATP_MODE_SV32X4 << HGATP_MODE_SHIFT);
+static unsigned long gstage_pgd_levels = 2;
+#define gstage_index_bits 10
+#endif
+```
+
+涉及 `hgatp` 的更新有两种情况：`kvm_arch_vcpu_create` -> `kvm_riscv_reset_vcpu` -> `kvm_arch_vcpu_load` -> `kvm_riscv_gstage_update_hgatp` 和 `kvm_arch_vcpu_ioctl_run` -> `kvm_riscv_check_vcpu_requests` -> `kvm_riscv_gstage_update_hgatp`，即在创建 vCPU 时初始化、vCPU 运行时处理来自 Guest 的请求（sleep，reset，fence，update hgatp，etc.）
+
+```cpp
+// arch/riscv/kvm/vcpu.c: line 915
+int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)
+{
+ int ret;
+
+ // ...
+
+ vcpu_load(vcpu);
+
+ kvm_sigset_activate(vcpu);
+
+ ret = 1;
+ run->exit_reason = KVM_EXIT_UNKNOWN;
+ /* 处理 vCPU 内部请求的循环 */
+ while (ret > 0) {
+ // ...
+
+ /* 更新 VMID（内部将根据 VM 做出更新 hgatp 等请求）*/
+ kvm_riscv_gstage_vmid_update(vcpu);
+ /* 处理各个 vCPU 内部的请求 */
+ kvm_riscv_check_vcpu_requests(vcpu);
+
+ // ...
+
+ ret = kvm_riscv_vcpu_exit(vcpu, run, &trap);
+ }
+
+ kvm_sigset_deactivate(vcpu);
+
+ vcpu_put(vcpu);
+
+ kvm_vcpu_srcu_read_unlock(vcpu);
+
+ return ret;
+}
+
+```
+
+其中 vmid 的更新函数如下：
+
+```cpp
+// arch/riscv/kvm/vmid.c: line 71
+void kvm_riscv_gstage_vmid_update(struct kvm_vcpu *vcpu)
+{
+ unsigned long i;
+ struct kvm_vcpu *v;
+ struct kvm_vmid *vmid = &vcpu->kvm->arch.vmid;
+
+ /* 视情况更新 vmid 版本并刷新 TLB */
+ if (!kvm_riscv_gstage_vmid_ver_changed(vmid))
+ return;
+ spin_lock(&vmid_lock);
+ // ...
+ spin_unlock(&vmid_lock);
+
+ /* 为每一个 vCPU 更新页表的刷新请求 */
+ /* Request G-stage page table update for all VCPUs */
+ kvm_for_each_vcpu(i, v, vcpu->kvm)
+ kvm_make_request(KVM_REQ_UPDATE_HGATP, v);
+}
+```
+
+在更新了 VMID 及其对应的 vCPU 内部的处理请求之后，将通过调用 `kvm_riscv_check_vcpu_requests` 函数进行处理：
+
+```cpp
+// arch/riscv/kvm/vcpu.c: line 848
+static void kvm_riscv_check_vcpu_requests(struct kvm_vcpu *vcpu)
+{
+ struct rcuwait *wait = kvm_arch_vcpu_get_wait(vcpu);
+
+ if (kvm_request_pending(vcpu)) {
+ /* sleep, reset requests handling */
+ // ...
+
+ if (kvm_check_request(KVM_REQ_UPDATE_HGATP, vcpu))
+ kvm_riscv_gstage_update_hgatp(vcpu);
+
+ /* Memory management requests (fence.i, hfence.gvma, hfence.vvma, etc.) handling */
+ // ...
+ }
+}
+```
+
+### HFENCE 扩展指令的实现
+
+与 H 扩展相关的内存管理指令包含了 `HINVAL` 扩展 和 `HFENCE` 扩展，其指令格式和功能参见 [此文][3]。`HINVAL` 指令 KVM 中并未予以实现，`HFENCE` 指令则在 `tlb.c` 中通过调用 `make_xfence_request` 实现。以 `hfence.gvma` 为例，其实现如下：
+
+```cpp
+// arch/riscv/kvm/tlb.c: line 388
+void kvm_riscv_hfence_gvma_vmid_gpa(struct kvm *kvm,
+ unsigned long hbase, unsigned long hmask,
+ gpa_t gpa, gpa_t gpsz,
+ unsigned long order)
+{
+ struct kvm_riscv_hfence data;
+
+ data.type = KVM_RISCV_HFENCE_GVMA_VMID_GPA;
+ data.asid = 0;
+ data.addr = gpa;
+ data.size = gpsz;
+ data.order = order;
+ make_xfence_request(kvm, hbase, hmask, KVM_REQ_HFENCE,
+ KVM_REQ_HFENCE_GVMA_VMID_ALL, &data);
+}
+```
+
+KVM 的实现中，根据指令对应的不同的使用场景，可大致分为如下四类实现：all 对应由 VMID 或 ASID 所指定的 TLB 的所有项，gpa 和 gva 则分别进一步指定了要处理的 TLB 项对应的 Guest/VM 地址。
+| hfence | Guest/Virtual | vmid/asid | address space |
+|------------------------|---------------|-----------|---------------|
+| kvm_riscv_local_hfence | gvma | vmid | gpa |
+| kvm_riscv_local_hfence | gvma | vmid | all |
+| kvm_riscv_local_hfence | vvma | asid | gva |
+| kvm_riscv_local_hfence | vvma | asid | all |
+
+`xfence` 的定义如下：
+
+```cpp
+// arch/riscv/kvm/tlb.c: line 345
+static void make_xfence_request(struct kvm *kvm,
+ unsigned long hbase, unsigned long hmask,
+ unsigned int req, unsigned int fallback_req,
+ const struct kvm_riscv_hfence *data)
+{
+ // ...
+
+ /* 将每个 vCPU 的 hfence 信息入队 */
+ kvm_for_each_vcpu(i, vcpu, kvm) {
+ // ...
+ if (!vcpu_hfence_enqueue(vcpu, data))
+ actual_req = fallback_req;
+ }
+
+ /* 若队满无法全部入队，则直接提交名为 fallback_req 的请求，对于指定了 VMID 和 GPA 的 hfence.gvma 指令而言，其 fallback_req 为刷新对应 VMID 的全部 TLB 项的 `KVM_REQ_HFENCE_GVMA_VMID_ALL`，以此保证即便不能做到精细化的内存管理，也可以通过粗粒度的指令达成所需的效果。*/
+ kvm_make_vcpus_request_mask(kvm, actual_req, vcpu_mask);
+}
+```
+
+### 总览
+
+整个过程中的调用关系如下图所示：
+
+```mermaid
+flowchart LR
+
+subgraph arch/riscv/kvm/mmu.c
+
+alloc_pgd[kvm_riscv_gstage_alloc_pgd]
+free_pgd[kvm_riscv_gstage_free_pgd]
+
+unmap[gstage_unmap_range]-->free_pgd
+
+leaf[gstage_get_leaf_entry]-->free_pgd
+l2s[gstage_level_to_page_size]-->op_pte
+op_pte[gstage_op_pte]-->free_pgd
+
+flush[gstage_remote_tlb_flush]-->op_pte
+
+gmap[kvm_riscv_gstage_map]
+
+mode_dtct[kvm_riscv_gstage_mode_detect]
+mode[kvm_riscv_gstage_mode]
+
+update_hgatp[kvm_riscv_gstage_update_hgatp]
+
+gpa_bits[kvm_riscv_gstage_gpa_bits]
+
+update_hgatp[kvm_riscv_gstage_update_hgatp]
+
+flush_shadow[kvm_arch_flush_shadow_all]
+
+pgva[gstage_pte_page_vaddr]-->leaf
+
+set_pte[gstage_set_pte]-->mappg[gstage_map_page]
+set_pte-->ioremap[kvm_riscv_gstage_ioremap]
+
+mappg-->set_gfn[kvm_set_spte_gfn]
+mappg-->gmap[kvm_riscv_gstage_map]
+
+end
+
+subgraph arch/riscv/kvm/vmid.c
+vmid_init[kvm_riscv_gstage_vmid_init]
+bits[kvm_riscv_gstage_vmid_bits]
+vmid_dtct[kvm_riscv_gstage_vmid_detect]
+vmid_change[kvm_riscv_gstage_vmid_ver_changed]
+update[kvm_riscv_gstage_vmid_update]
+end
+
+subgraph arch/riscv/kvm/vm.c
+ivm[kvm_arch_init_vm]
+check_ext[kvm_vm_ioctl_check_extension]
+end
+
+subgraph virt/kvm/kvm_main.c
+cvm[kvm_create_vm]
+mem[kvm_mmu_topup_memory_cache]
+dev_vm[kvm_dev_ioctl_create_vm]
+dev[kvm_dev_ioctl]
+
+init[kvm_init]
+
+set_gfn-->mn_pte[kvm_mmu_notifier_change_pte]
+flush_shadow-->flush_all[kvm_flush_shadow_all]
+
+cvm-->dev_vm
+dev_vm-->dev
+
+end
+
+dev-->external_call[kvmtool, etc.]
+
+subgraph arch/riscv/kvm/vcpu_exit.c
+pgfault[gstage_page_fault]
+end
+
+subgraph arch/riscv/kvm/main.c
+rkinit[riscv_kvm_init]
+archi[kvm_arch_init]
+end
+
+archi-->init-->rkinit
+
+subgraph arch/riscv/kvm/tlb.c
+tlb_sntz[kvm_riscv_local_tlb_sanitize]
+end
+
+subgraph arch/riscv/kvm/vcpu.c
+run[kvm_arch_vcpu_ioctl_run]
+load[kvm_arch_vcpu_load]
+check_vcpu_req[kvm_riscv_check_vcpu_requests]
+end
+
+alloc_pgd-->ivm
+vmid_init-->ivm
+free_pgd-->ivm
+
+ivm-->cvm
+
+gmap-->pgfault
+
+mode_dtct-->archi
+vmid_dtct-->archi
+mode-->archi
+
+bits-->archi
+bits-->update_hgatp
+bits-->tlb_sntz
+
+vmid_change-->run
+update-->run
+
+gpa_bits-->check_ext
+
+update_hgatp-->load
+update_hgatp-->check_vcpu_req
+
+mem-->gmap
+
+```
+
+（[下载由 Mermaid 生成的 PNG 图片][009]）
+
+## kvmtool
+
+kvmtool 为 Guest 申请内存的行为并不太多涉及特定架构的虚拟化支持的细节，kvmtool 初始化 VM 内存的函数如下所示：
+
+```cpp
+// riscv/kvm.c: line 64
+void kvm__arch_init(struct kvm *kvm)
+{
+ /* 申请 Guest 内存。Buffer 做 64K 对齐，如使用了 THP（Transparent Huge Page）则按 2M 对齐 */
+
+ /* 确定 Guest 内存的起始位置与大小 */
+ kvm->ram_size = min(kvm->cfg.ram_size, (u64)RISCV_MAX_MEMORY(kvm));
+ kvm->arch.ram_alloc_size = kvm->ram_size + SZ_2M;
+ kvm->arch.ram_alloc_start = mmap_anon_or_hugetlbfs(kvm,
+ kvm->cfg.hugetlbfs_path,
+ kvm->arch.ram_alloc_size);
+ if (kvm->arch.ram_alloc_start == MAP_FAILED)
+ die("Failed to map %lld bytes for guest memory (%d)",
+ kvm->arch.ram_alloc_size, errno);
+ kvm->ram_start = (void *)ALIGN((unsigned long)kvm->arch.ram_alloc_start,
+ SZ_2M);
+
+ /* 为 Guest 申请特定类型的内存 */
+ madvise(kvm->arch.ram_alloc_start, kvm->arch.ram_alloc_size,
+ MADV_MERGEABLE);
+ madvise(kvm->arch.ram_alloc_start, kvm->arch.ram_alloc_size,
+ MADV_HUGEPAGE);
+}
+```
+
+## 结语
+
+本文对 KVM 如何实现 RISC-V G-Stage 地址转换进行了分析，包括为 Guest 申请内存、处理 G-Stage 页错误、使用 HFENCE 指令管理内存、更新 HGATP 寄存器、释放 VM 的内存，后续可作为 RISC-V 虚拟化的软件实现的参考。
+
+## 参考资料
+
+- [RISC-V 特权指令集手册][4]
+- [RISC-V Linux][5]
+- [kvmtools][6]
+
+[1]: 20221011-riscv-kvm-mem-virt-impl.md#h-扩展特殊指令的实现
+[2]: 20220812-riscv-kvm-mem-virt-1.md#hgatp
+[3]: 20220812-riscv-kvm-mem-virt-2.md
+[4]: https://riscv.org/technical/specifications/privileged-isa/
+[5]: https://gitee.com/tinylab/riscv-linux
+[6]: https://git.kernel.org/pub/scm/linux/kernel/git/will/kvmtool.git
+[007]: https://mp.weixin.qq.com/s/nlMGEhuaDUYqV6r8A4cRlA
+[008]: images/riscv-kvm/vm-impl/mermaid-riscv-kvm-mem-virt-impl-1.png
+[009]: images/riscv-kvm/vm-impl/mermaid-riscv-kvm-mem-virt-impl-2.png
diff --git a/articles/images/riscv-kvm/vm-impl/gstage-at.png b/articles/images/riscv-kvm/vm-impl/gstage-at.png
new file mode 100644
index 0000000000000000000000000000000000000000..2d438ed97c9768e5023daa1d62f913a7fb31561a
GIT binary patch
literal 39305
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
literal 0
HcmV?d00001
diff --git a/articles/images/riscv-kvm/vm-impl/mermaid-riscv-kvm-mem-virt-impl-1.png b/articles/images/riscv-kvm/vm-impl/mermaid-riscv-kvm-mem-virt-impl-1.png
new file mode 100644
index 0000000000000000000000000000000000000000..468dfa2d388796496ce427ca9a162cb20df9eb23
GIT binary patch
literal 12205
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