diff mbox series

[RFC,6/6] KVM: add KVM_SPLIT_MEMORY_REGION

Message ID 20211111141352.26311-7-chao.p.peng@linux.intel.com (mailing list archive)
State New, archived
Headers show
Series KVM: mm: fd-based approach for supporting KVM guest private memory | expand

Commit Message

Chao Peng Nov. 11, 2021, 2:13 p.m. UTC 
This new ioctl let user to split an exising memory region into two
parts. The first part reuses the existing memory region but have a
shrinked size. The second part is a newly created one.

Signed-off-by: Yu Zhang <yu.c.zhang@linux.intel.com>
Signed-off-by: Chao Peng <chao.p.peng@linux.intel.com>
---
 arch/x86/kvm/x86.c       |   3 +-
 include/linux/kvm_host.h |   4 ++
 include/uapi/linux/kvm.h |  16 +++++
 virt/kvm/kvm_main.c      | 147 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 169 insertions(+), 1 deletion(-)
diff mbox series

Patch

diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 98dbe602f47b..1d490c3d7766 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -11020,7 +11020,8 @@  int kvm_arch_prepare_memory_region(struct kvm *kvm,
 				const struct kvm_userspace_memory_region *mem,
 				enum kvm_mr_change change)
 {
-	if (change == KVM_MR_CREATE || change == KVM_MR_MOVE)
+	if (change == KVM_MR_CREATE || change == KVM_MR_MOVE ||
+	    change == KVM_MR_SHRINK)
 		return kvm_alloc_memslot_metadata(memslot,
 						  mem->memory_size >> PAGE_SHIFT);
 	return 0;
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 17fabb4f53bf..8b5a9217231b 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -752,6 +752,9 @@  static inline bool memslot_is_private(const struct kvm_memory_slot *slot)
  *   -- move it in the guest physical memory space
  *   -- just change its flags
  *
+ * KVM_SPLIT_MEMORY_REGION ioctl allows the following operation:
+ * - shrink an existing memory slot
+ *
  * Since flags can be changed by some of these operations, the following
  * differentiation is the best we can do for __kvm_set_memory_region():
  */
@@ -760,6 +763,7 @@  enum kvm_mr_change {
 	KVM_MR_DELETE,
 	KVM_MR_MOVE,
 	KVM_MR_FLAGS_ONLY,
+	KVM_MR_SHRINK,
 };
 
 int kvm_set_memory_region(struct kvm *kvm,
diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h
index 470c472a9451..e61c0eac91e7 100644
--- a/include/uapi/linux/kvm.h
+++ b/include/uapi/linux/kvm.h
@@ -1108,6 +1108,7 @@  struct kvm_ppc_resize_hpt {
 #define KVM_CAP_DIRTY_LOG_RING 192
 #define KVM_CAP_X86_BUS_LOCK_EXIT 193
 #define KVM_CAP_PPC_DAWR1 194
+#define KVM_CAP_MEMORY_REGION_SPLIT 195
 
 #define KVM_CAP_VM_TYPES 1000
 
@@ -1885,4 +1886,19 @@  struct kvm_dirty_gfn {
 #define KVM_BUS_LOCK_DETECTION_OFF             (1 << 0)
 #define KVM_BUS_LOCK_DETECTION_EXIT            (1 << 1)
 
+/**
+ * struct kvm_split_memory_region_info - Infomation for memory region split.
+ * @slot1: The slot to be split.
+ * @slot2: The slot for the newly split part.
+ * @offset: The offset(bytes) in @slot1 to split.
+ */
+struct kvm_split_memory_region_info {
+	__u32 slot1;
+	__u32 slot2;
+	__u64 offset;
+};
+
+#define KVM_SPLIT_MEMORY_REGION _IOW(KVMIO, 0xcf, \
+					struct kvm_split_memory_region_info)
+
 #endif /* __LINUX_KVM_H */
diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index e8e2c5b28aa4..11b0f3d8b9ee 100644
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -1467,6 +1467,140 @@  static int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
 	return kvm_set_memory_region(kvm, mem);
 }
 
+static void memslot_to_memory_region(struct kvm_userspace_memory_region *mem,
+				struct kvm_memory_slot *slot)
+{
+	mem->slot = (u32)slot->as_id << 16 | slot->id;
+	mem->flags = slot->flags;
+	mem->guest_phys_addr = slot->base_gfn >> PAGE_SHIFT;
+	mem->memory_size = slot->npages << PAGE_SHIFT;
+	mem->userspace_addr = slot->userspace_addr;
+}
+
+static int kvm_split_memory_region(struct kvm *kvm, int as_id, int id1, int id2,
+					gfn_t offset)
+{
+	struct kvm_memory_slot *slot1;
+	struct kvm_memory_slot slot2, old;
+	struct kvm_userspace_memory_region mem;
+	unsigned long *dirty_bitmap_slot1;
+	struct kvm_memslots *slots;
+	int r;
+
+	/* Make a full copy of the old memslot. */
+	slot1 = id_to_memslot(__kvm_memslots(kvm, as_id), id1);
+	if (!slot1)
+		return -EINVAL;
+	else
+		old = *slot1;
+
+	if( offset <= old.base_gfn ||
+	    offset >= old.base_gfn + old.npages )
+		return -EINVAL;
+
+	/* Prepare the second half. */
+	slot2.as_id = as_id;
+	slot2.id = id2;
+	slot2.base_gfn = old.npages + offset;
+	slot2.npages = old.npages - offset;
+	slot2.flags = old.flags;
+	slot2.userspace_addr = old.userspace_addr + (offset >> PAGE_SHIFT);
+	slot2.file = old.file;
+	slot2.private_ops = old.private_ops;
+
+	if (!(old.flags & KVM_MEM_LOG_DIRTY_PAGES))
+		slot2.dirty_bitmap = NULL;
+	else if (!kvm->dirty_ring_size) {
+		slot1->npages = offset;
+		r = kvm_alloc_dirty_bitmap(slot1);
+		if (r)
+			return r;
+		else
+			dirty_bitmap_slot1 = slot1->dirty_bitmap;
+
+		r = kvm_alloc_dirty_bitmap(&slot2);
+		if (r)
+			goto out_bitmap;
+
+		//TODO: copy dirty_bitmap or return -EINVAL if logging is running
+	}
+
+//	mutex_lock(&kvm->slots_arch_lock);
+
+	slots = kvm_dup_memslots(__kvm_memslots(kvm, as_id), KVM_MR_CREATE);
+	if (!slots) {
+//		mutex_unlock(&kvm->slots_arch_lock);
+		r = -ENOMEM;
+		goto out_bitmap;
+	}
+
+	slot1 = id_to_memslot(slots, id1);
+	slot1->npages = offset;
+	slot1->dirty_bitmap = dirty_bitmap_slot1;
+
+	memslot_to_memory_region(&mem, slot1);
+	r = kvm_arch_prepare_memory_region(kvm, slot1, &mem, KVM_MR_SHRINK);
+	if (r)
+		goto out_slots;
+
+	memslot_to_memory_region(&mem, &slot2);
+	r = kvm_arch_prepare_memory_region(kvm, &slot2, &mem, KVM_MR_CREATE);
+	if (r)
+		goto out_slots;
+
+	update_memslots(slots, slot1, KVM_MR_SHRINK);
+	update_memslots(slots, &slot2, KVM_MR_CREATE);
+
+	slots = install_new_memslots(kvm, as_id, slots);
+
+	kvm_free_memslot(kvm, &old);
+
+	kvfree(slots);
+	return 0;
+
+out_slots:
+//	mutex_unlock(&kvm->slots_arch_lock);
+	kvfree(slots);
+out_bitmap:
+	if (dirty_bitmap_slot1)
+		kvm_destroy_dirty_bitmap(slot1);
+	if (slot2.dirty_bitmap)
+		kvm_destroy_dirty_bitmap(&slot2);
+
+	return r;
+}
+
+static int kvm_vm_ioctl_split_memory_region(struct kvm *kvm,
+				struct kvm_split_memory_region_info *info)
+{
+	int as_id1, as_id2, id1, id2;
+	int r;
+
+	if ((u16)info->slot1 >= KVM_USER_MEM_SLOTS ||
+	    (u16)info->slot2 >= KVM_USER_MEM_SLOTS)
+		return -EINVAL;
+	if (info->offset & (PAGE_SIZE - 1))
+		return -EINVAL;
+
+	as_id1 = info->slot1 >> 16;
+	as_id2 = info->slot2 >> 16;
+
+	if (as_id1 != as_id2 || as_id1 >= KVM_ADDRESS_SPACE_NUM)
+		return -EINVAL;
+
+	id1 = (u16)info->slot1;
+	id2 = (u16)info->slot2;
+	if (id1 == id2 || id1 >= KVM_MEM_SLOTS_NUM || id2 >= KVM_MEM_SLOTS_NUM)
+		return -EINVAL;
+
+	mutex_lock(&kvm->slots_lock);
+	r = kvm_split_memory_region(kvm, as_id1, id1, id2,
+					info->offset >> PAGE_SHIFT);
+	mutex_unlock(&kvm->slots_lock);
+
+	return r;
+}
+
 #ifndef CONFIG_KVM_GENERIC_DIRTYLOG_READ_PROTECT
 /**
  * kvm_get_dirty_log - get a snapshot of dirty pages
@@ -3765,6 +3899,8 @@  static long kvm_vm_ioctl_check_extension_generic(struct kvm *kvm, long arg)
 #else
 		return 0;
 #endif
+	case KVM_CAP_MEMORY_REGION_SPLIT:
+		return 1;
 	default:
 		break;
 	}
@@ -3901,6 +4037,17 @@  static long kvm_vm_ioctl(struct file *filp,
 		r = kvm_vm_ioctl_set_memory_region(kvm, &kvm_userspace_mem);
 		break;
 	}
+	case KVM_SPLIT_MEMORY_REGION: {
+		struct kvm_split_memory_region_info info;
+
+		r = -EFAULT;
+		if (copy_from_user(&info, argp, sizeof(info)))
+			goto out;
+
+		r = kvm_vm_ioctl_split_memory_region(kvm, &info);
+		break;
+	}
+
 	case KVM_GET_DIRTY_LOG: {
 		struct kvm_dirty_log log;