1 // SPDX-License-Identifier: GPL-2.0
3 * ACRN: Memory mapping management
5 * Copyright (C) 2020 Intel Corporation. All rights reserved.
8 * Fei Li <lei1.li@intel.com>
9 * Shuo Liu <shuo.a.liu@intel.com>
14 #include <linux/slab.h>
18 static int modify_region(struct acrn_vm *vm, struct vm_memory_region_op *region)
20 struct vm_memory_region_batch *regions;
23 regions = kzalloc(sizeof(*regions), GFP_KERNEL);
27 regions->vmid = vm->vmid;
28 regions->regions_num = 1;
29 regions->regions_gpa = virt_to_phys(region);
31 ret = hcall_set_memory_regions(virt_to_phys(regions));
33 dev_dbg(acrn_dev.this_device,
34 "Failed to set memory region for VM[%u]!\n", vm->vmid);
41 * acrn_mm_region_add() - Set up the EPT mapping of a memory region.
43 * @user_gpa: A GPA of User VM.
44 * @service_gpa: A GPA of Service VM.
45 * @size: Size of the region.
46 * @mem_type: Combination of ACRN_MEM_TYPE_*.
47 * @mem_access_right: Combination of ACRN_MEM_ACCESS_*.
49 * Return: 0 on success, <0 on error.
51 int acrn_mm_region_add(struct acrn_vm *vm, u64 user_gpa, u64 service_gpa,
52 u64 size, u32 mem_type, u32 mem_access_right)
54 struct vm_memory_region_op *region;
57 region = kzalloc(sizeof(*region), GFP_KERNEL);
61 region->type = ACRN_MEM_REGION_ADD;
62 region->user_vm_pa = user_gpa;
63 region->service_vm_pa = service_gpa;
65 region->attr = ((mem_type & ACRN_MEM_TYPE_MASK) |
66 (mem_access_right & ACRN_MEM_ACCESS_RIGHT_MASK));
67 ret = modify_region(vm, region);
69 dev_dbg(acrn_dev.this_device,
70 "%s: user-GPA[%pK] service-GPA[%pK] size[0x%llx].\n",
71 __func__, (void *)user_gpa, (void *)service_gpa, size);
77 * acrn_mm_region_del() - Del the EPT mapping of a memory region.
79 * @user_gpa: A GPA of the User VM.
80 * @size: Size of the region.
82 * Return: 0 on success, <0 for error.
84 int acrn_mm_region_del(struct acrn_vm *vm, u64 user_gpa, u64 size)
86 struct vm_memory_region_op *region;
89 region = kzalloc(sizeof(*region), GFP_KERNEL);
93 region->type = ACRN_MEM_REGION_DEL;
94 region->user_vm_pa = user_gpa;
95 region->service_vm_pa = 0UL;
99 ret = modify_region(vm, region);
101 dev_dbg(acrn_dev.this_device, "%s: user-GPA[%pK] size[0x%llx].\n",
102 __func__, (void *)user_gpa, size);
107 int acrn_vm_memseg_map(struct acrn_vm *vm, struct acrn_vm_memmap *memmap)
111 if (memmap->type == ACRN_MEMMAP_RAM)
112 return acrn_vm_ram_map(vm, memmap);
114 if (memmap->type != ACRN_MEMMAP_MMIO) {
115 dev_dbg(acrn_dev.this_device,
116 "Invalid memmap type: %u\n", memmap->type);
120 ret = acrn_mm_region_add(vm, memmap->user_vm_pa,
121 memmap->service_vm_pa, memmap->len,
122 ACRN_MEM_TYPE_UC, memmap->attr);
124 dev_dbg(acrn_dev.this_device,
125 "Add memory region failed, VM[%u]!\n", vm->vmid);
130 int acrn_vm_memseg_unmap(struct acrn_vm *vm, struct acrn_vm_memmap *memmap)
134 if (memmap->type != ACRN_MEMMAP_MMIO) {
135 dev_dbg(acrn_dev.this_device,
136 "Invalid memmap type: %u\n", memmap->type);
140 ret = acrn_mm_region_del(vm, memmap->user_vm_pa, memmap->len);
142 dev_dbg(acrn_dev.this_device,
143 "Del memory region failed, VM[%u]!\n", vm->vmid);
149 * acrn_vm_ram_map() - Create a RAM EPT mapping of User VM.
150 * @vm: The User VM pointer
151 * @memmap: Info of the EPT mapping
153 * Return: 0 on success, <0 for error.
155 int acrn_vm_ram_map(struct acrn_vm *vm, struct acrn_vm_memmap *memmap)
157 struct vm_memory_region_batch *regions_info;
158 int nr_pages, i = 0, order, nr_regions = 0;
159 struct vm_memory_mapping *region_mapping;
160 struct vm_memory_region_op *vm_region;
161 struct page **pages = NULL, *page;
169 /* Get the page number of the map region */
170 nr_pages = memmap->len >> PAGE_SHIFT;
171 pages = vzalloc(nr_pages * sizeof(struct page *));
175 /* Lock the pages of user memory map region */
176 pinned = pin_user_pages_fast(memmap->vma_base,
177 nr_pages, FOLL_WRITE | FOLL_LONGTERM,
182 } else if (pinned != nr_pages) {
187 /* Create a kernel map for the map region */
188 remap_vaddr = vmap(pages, nr_pages, VM_MAP, PAGE_KERNEL);
194 /* Record Service VM va <-> User VM pa mapping */
195 mutex_lock(&vm->regions_mapping_lock);
196 region_mapping = &vm->regions_mapping[vm->regions_mapping_count];
197 if (vm->regions_mapping_count < ACRN_MEM_MAPPING_MAX) {
198 region_mapping->pages = pages;
199 region_mapping->npages = nr_pages;
200 region_mapping->size = memmap->len;
201 region_mapping->service_vm_va = remap_vaddr;
202 region_mapping->user_vm_pa = memmap->user_vm_pa;
203 vm->regions_mapping_count++;
205 dev_warn(acrn_dev.this_device,
206 "Run out of memory mapping slots!\n");
208 mutex_unlock(&vm->regions_mapping_lock);
211 mutex_unlock(&vm->regions_mapping_lock);
213 /* Calculate count of vm_memory_region_op */
214 while (i < nr_pages) {
216 VM_BUG_ON_PAGE(PageTail(page), page);
217 order = compound_order(page);
222 /* Prepare the vm_memory_region_batch */
223 regions_info = kzalloc(sizeof(*regions_info) +
224 sizeof(*vm_region) * nr_regions,
228 goto unmap_kernel_map;
231 /* Fill each vm_memory_region_op */
232 vm_region = (struct vm_memory_region_op *)(regions_info + 1);
233 regions_info->vmid = vm->vmid;
234 regions_info->regions_num = nr_regions;
235 regions_info->regions_gpa = virt_to_phys(vm_region);
236 user_vm_pa = memmap->user_vm_pa;
238 while (i < nr_pages) {
242 VM_BUG_ON_PAGE(PageTail(page), page);
243 order = compound_order(page);
244 region_size = PAGE_SIZE << order;
245 vm_region->type = ACRN_MEM_REGION_ADD;
246 vm_region->user_vm_pa = user_vm_pa;
247 vm_region->service_vm_pa = page_to_phys(page);
248 vm_region->size = region_size;
249 vm_region->attr = (ACRN_MEM_TYPE_WB & ACRN_MEM_TYPE_MASK) |
250 (memmap->attr & ACRN_MEM_ACCESS_RIGHT_MASK);
253 user_vm_pa += region_size;
257 /* Inform the ACRN Hypervisor to set up EPT mappings */
258 ret = hcall_set_memory_regions(virt_to_phys(regions_info));
260 dev_dbg(acrn_dev.this_device,
261 "Failed to set regions, VM[%u]!\n", vm->vmid);
266 dev_dbg(acrn_dev.this_device,
267 "%s: VM[%u] service-GVA[%pK] user-GPA[%pK] size[0x%llx]\n",
269 remap_vaddr, (void *)memmap->user_vm_pa, memmap->len);
275 mutex_lock(&vm->regions_mapping_lock);
276 vm->regions_mapping_count--;
277 mutex_unlock(&vm->regions_mapping_lock);
281 for (i = 0; i < pinned; i++)
282 unpin_user_page(pages[i]);
289 * acrn_vm_all_ram_unmap() - Destroy a RAM EPT mapping of User VM.
292 void acrn_vm_all_ram_unmap(struct acrn_vm *vm)
294 struct vm_memory_mapping *region_mapping;
297 mutex_lock(&vm->regions_mapping_lock);
298 for (i = 0; i < vm->regions_mapping_count; i++) {
299 region_mapping = &vm->regions_mapping[i];
300 vunmap(region_mapping->service_vm_va);
301 for (j = 0; j < region_mapping->npages; j++)
302 unpin_user_page(region_mapping->pages[j]);
303 vfree(region_mapping->pages);
305 mutex_unlock(&vm->regions_mapping_lock);