Skip to contentSkip to conversation

Add guest_memfd support for arm64

PATCH Superseded Fuad Tabba 2 participants 9 messages Jul 8 – Jul 9

Subsystems (2)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore

Fuad Tabba

author reviewer
#0 lore raw

v2 cover Add guest_memfd support for arm64

Hi folks,

Changes since v1 [1]:
- Use kvm_userspace_memory_region2 only for guest_memfd slots (Suzuki)
- Check KVM_CAP_GUEST_MEMFD before KVM_CAP_GUEST_MEMFD_FLAGS (Alexandru)
- Close guest_memfd fd after unmapping at teardown (Alexandru)
- Carried Reviewed-bys

Due to popular demand, i.e., Alexandru asking me about it, I repolished my guest_memfd support series. The one I sent years ago was stale and over-engineered, so this is a fresh start instead.

This series adds support for backing guest RAM with guest_memfd on arm64, for non-protected VMs under both regular KVM and pKVM.

The first two patches are standalone fixes in the code this series builds on: an uninitialized return value in kvm__for_each_mem_bank(), and doubled newlines in die() messages. Patch 3 adds guest_memfd plumbing to kvm__register_mem(), using kvm_userspace_memory_region2 only for guest_memfd-backed slots.

A new --guest-memfd option creates guest RAM from a guest_memfd with mmap support (GUEST_MEMFD_FLAG_MMAP and GUEST_MEMFD_FLAG_INIT_SHARED, Linux 6.18+), maps it to provide the userspace mapping, and registers it with KVM_SET_USER_MEMORY_REGION2.

Protected VMs need in-place shared/private conversion of guest_memfd, which is still in progress in the kernel [2], so --protected rejects the option.

Based on kvmtool master (ca0ddafa941d).

Cheers,
/fuad

[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/[email protected]/

Fuad Tabba (4):
Initialize the return value in kvm__for_each_mem_bank() Remove newline from end of die() aborts
Add support for registering guest_memfd-backed memory regions
arm64: Add --guest-memfd option to back guest RAM with guest_memfd

 arm64/include/kvm/kvm-config-arch.h |  5 ++-
 arm64/kvm.c                         | 43 +++++++++++++++++++++-----
 hw/cfi_flash.c                      |  2 +-
 include/kvm/kvm.h                   | 16 ++++++++--
 include/kvm/util.h                  |  1 +
 kvm.c                               | 42 ++++++++++++++++++--------
 util/util.c                         | 47 ++++++++++++++++++++++++++---
 7 files changed, 127 insertions(+), 29 deletions(-)
Signature · 1 line
2.39.5
author reviewer
#1 lore raw

PATCH v2 1/4 Initialize the return value in kvm__for_each_mem_bank()

If none of the bank types match, the function would return an uninitialized value.

---
 kvm.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)
kvm.c +3 -2
index 7a52c6a..95ccfcb 100644
@@ -383,14 +383,15 @@ u64 host_to_guest_flat(struct kvm *kvm, void *ptr)
  * their type.
  *
  * If one call to @fun returns a non-zero value, stop iterating and return the
- * value. Otherwise, return zero.
+ * value. If none of the bank types match, return -ENODEV. Otherwise, return
+ * zero.
  */
 int kvm__for_each_mem_bank(struct kvm *kvm, enum kvm_mem_type type,
 			   int (*fun)(struct kvm *kvm, struct kvm_mem_bank *bank, void *data),
 			   void *data)
 {
-	int ret;
 	struct kvm_mem_bank *bank;
+	int ret = -ENODEV;
 
 	list_for_each_entry(bank, &kvm->mem_banks, list) {
 		if (type != KVM_MEM_TYPE_ALL && !(bank->type & type))
Signature · 1 line
2.39.5
author reviewer
#2 lore raw

PATCH v2 2/4 Remove newline from end of die() aborts

In reply to Fuad Tabba

die() already adds the newline at the end of the string.

---
 util/util.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)
util/util.c +5 -5
index 6f41e2c..05d49c4 100644
@@ -128,14 +128,14 @@ void *mmap_hugetlbfs(struct kvm *kvm, const char *htlbfs_path, u64 size)
 	unsigned long blk_size;
 
 	if (statfs(htlbfs_path, &sfs) < 0)
-		die("Can't stat %s\n", htlbfs_path);
+		die("Can't stat %s", htlbfs_path);
 
 	if ((unsigned int)sfs.f_type != HUGETLBFS_MAGIC)
-		die("%s is not hugetlbfs!\n", htlbfs_path);
+		die("%s is not hugetlbfs!", htlbfs_path);
 
 	blk_size = (unsigned long)sfs.f_bsize;
 	if (sfs.f_bsize == 0 || blk_size > size) {
-		die("Can't use hugetlbfs pagesize %ld for mem size %lld\n",
+		die("Can't use hugetlbfs pagesize %ld for mem size %lld",
 			blk_size, (unsigned long long)size);
 	}
 
@@ -144,10 +144,10 @@ void *mmap_hugetlbfs(struct kvm *kvm, const char *htlbfs_path, u64 size)
 	snprintf(mpath, PATH_MAX, "%s/kvmtoolXXXXXX", htlbfs_path);
 	fd = mkstemp(mpath);
 	if (fd < 0)
-		die("Can't open %s for hugetlbfs map\n", mpath);
+		die("Can't open %s for hugetlbfs map", mpath);
 	unlink(mpath);
 	if (ftruncate(fd, size) < 0)
-		die("Can't ftruncate for mem mapping size %lld\n",
+		die("Can't ftruncate for mem mapping size %lld",
 			(unsigned long long)size);
 	addr = mmap(NULL, size, PROT_RW, MAP_PRIVATE, fd, 0);
 	close(fd);
Signature · 1 line
2.39.5
author reviewer
#3 lore raw

PATCH v2 3/4 Add support for registering guest_memfd-backed memory regions

In reply to Fuad Tabba

Extend kvm__register_mem() with a guest_memfd file descriptor and offset. A bank with a guest_memfd is registered with KVM_SET_USER_MEMORY_REGION2 and KVM_MEM_GUEST_MEMFD, binding the memslot to the file. This prepares for backing guest RAM with guest_memfd on arm64.

---
 hw/cfi_flash.c    |  2 +-
 include/kvm/kvm.h | 15 +++++++++++++--
 kvm.c             | 36 ++++++++++++++++++++++++++----------
 3 files changed, 40 insertions(+), 13 deletions(-)
hw/cfi_flash.c +1 -1
index b68d9e0..4413955 100644
@@ -451,7 +451,7 @@ static int map_flash_memory(struct kvm *kvm, struct cfi_flash_device *sfdev)
 	int ret;
 
 	ret = kvm__register_mem(kvm, sfdev->base_addr, sfdev->size,
-				sfdev->flash_memory,
+				sfdev->flash_memory, -1, 0,
 				KVM_MEM_TYPE_RAM | KVM_MEM_TYPE_READONLY);
 	if (!ret)
 		sfdev->is_mapped = true;
include/kvm/kvm.h +13 -2
index eb23e2f..5e7b5eb 100644
@@ -128,11 +128,22 @@ bool kvm__emulate_io(struct kvm_cpu *vcpu, u16 port, void *data, int direction,
 bool kvm__emulate_mmio(struct kvm_cpu *vcpu, u64 phys_addr, u8 *data, u32 len, u8 is_write);
 int kvm__destroy_mem(struct kvm *kvm, u64 guest_phys, u64 size, void *userspace_addr);
 int kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size, void *userspace_addr,
+		      int guest_memfd, u64 guest_memfd_offset,
 		      enum kvm_mem_type type);
 static inline int kvm__register_ram(struct kvm *kvm, u64 guest_phys, u64 size,
 				    void *userspace_addr)
 {
 	return kvm__register_mem(kvm, guest_phys, size, userspace_addr,
+				 -1, 0, KVM_MEM_TYPE_RAM);
+}
+
+static inline int kvm__register_ram_guest_memfd(struct kvm *kvm, u64 guest_phys,
+						u64 size, void *userspace_addr,
+						int guest_memfd,
+						u64 guest_memfd_offset)
+{
+	return kvm__register_mem(kvm, guest_phys, size, userspace_addr,
+				 guest_memfd, guest_memfd_offset,
 				 KVM_MEM_TYPE_RAM);
 }
 
@@ -140,13 +151,13 @@ static inline int kvm__register_dev_mem(struct kvm *kvm, u64 guest_phys,
 					u64 size, void *userspace_addr)
 {
 	return kvm__register_mem(kvm, guest_phys, size, userspace_addr,
-				 KVM_MEM_TYPE_DEVICE);
+				 -1, 0, KVM_MEM_TYPE_DEVICE);
 }
 
 static inline int kvm__reserve_mem(struct kvm *kvm, u64 guest_phys, u64 size)
 {
 	return kvm__register_mem(kvm, guest_phys, size, NULL,
-				 KVM_MEM_TYPE_RESERVED);
+				 -1, 0, KVM_MEM_TYPE_RESERVED);
 }
 
 int __must_check kvm__register_iotrap(struct kvm *kvm, u64 phys_addr, u64 len,
kvm.c +26 -10
index 95ccfcb..947721b 100644
@@ -237,9 +237,9 @@ out:
 }
 
 int kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size,
-		      void *userspace_addr, enum kvm_mem_type type)
+		      void *userspace_addr, int guest_memfd,
+		      u64 guest_memfd_offset, enum kvm_mem_type type)
 {
-	struct kvm_userspace_memory_region mem;
 	struct kvm_mem_bank *merged = NULL;
 	struct kvm_mem_bank *bank;
 	struct list_head *prev_entry;
@@ -320,15 +320,31 @@ int kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size,
 		flags |= KVM_MEM_READONLY;
 
 	if (type != KVM_MEM_TYPE_RESERVED) {
-		mem = (struct kvm_userspace_memory_region) {
-			.slot			= slot,
-			.flags			= flags,
-			.guest_phys_addr	= guest_phys,
-			.memory_size		= size,
-			.userspace_addr		= (unsigned long)userspace_addr,
-		};
+		if (guest_memfd >= 0) {
+			struct kvm_userspace_memory_region2 mem2 = {
+				.slot			= slot,
+				.flags			= flags | KVM_MEM_GUEST_MEMFD,
+				.guest_phys_addr	= guest_phys,
+				.memory_size		= size,
+				.userspace_addr		= (unsigned long)userspace_addr,
+				.guest_memfd		= guest_memfd,
+				.guest_memfd_offset	= guest_memfd_offset,
+			};
 
-		ret = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &mem);
+			ret = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION2,
+				    &mem2);
+		} else {
+			struct kvm_userspace_memory_region mem = {
+				.slot			= slot,
+				.flags			= flags,
+				.guest_phys_addr	= guest_phys,
+				.memory_size		= size,
+				.userspace_addr		= (unsigned long)userspace_addr,
+			};
+
+			ret = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION,
+				    &mem);
+		}
 		if (ret < 0) {
 			ret = -errno;
 			goto out;
Signature · 1 line
2.39.5
Reviewed-by on v2 3/4
#4 lore raw

Re: [PATCH kvmtool v2 3/4] Add support for registering guest_memfd-backed memory regions

Hi Fuad,

Quoted 41 lines · Fuad Tabba

Extend kvm__register_mem() with a guest_memfd file descriptor and offset. A bank with a guest_memfd is registered with KVM_SET_USER_MEMORY_REGION2 and KVM_MEM_GUEST_MEMFD, binding the memslot to the file. This prepares for backing guest RAM with guest_memfd on arm64.

---
 hw/cfi_flash.c    |  2 +-
 include/kvm/kvm.h | 15 +++++++++++++--
 kvm.c             | 36 ++++++++++++++++++++++++++----------
 3 files changed, 40 insertions(+), 13 deletions(-)
hw/cfi_flash.c +1 -1
index b68d9e0..4413955 100644
@@ -451,7 +451,7 @@ static int map_flash_memory(struct kvm *kvm, struct cfi_flash_device *sfdev)
 	int ret;
 
 	ret = kvm__register_mem(kvm, sfdev->base_addr, sfdev->size,
-				sfdev->flash_memory,
+				sfdev->flash_memory, -1, 0,
 				KVM_MEM_TYPE_RAM | KVM_MEM_TYPE_READONLY);
 	if (!ret)
 		sfdev->is_mapped = true;
include/kvm/kvm.h +2 -0
index eb23e2f..5e7b5eb 100644
@@ -128,11 +128,22 @@ bool kvm__emulate_io(struct kvm_cpu *vcpu, u16 port, void *data, int direction,
 bool kvm__emulate_mmio(struct kvm_cpu *vcpu, u64 phys_addr, u8 *data, u32 len, u8 is_write);
 int kvm__destroy_mem(struct kvm *kvm, u64 guest_phys, u64 size, void *userspace_addr);
 int kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size, void *userspace_addr,
+		      int guest_memfd, u64 guest_memfd_offset,
 		      enum kvm_mem_type type);
 static inline int kvm__register_ram(struct kvm *kvm, u64 guest_phys, u64 size,
 				    void *userspace_addr)
 {
 	return kvm__register_mem(kvm, guest_phys, size, userspace_addr,
+				 -1, 0, KVM_MEM_TYPE_RAM);

include/kvm/kvm.h bool kvm__emulate_io(struct kvm_cpu *vcpu, u16 port, void *data, int direction, · line 147

Quoted 10 lines
include/kvm/kvm.h +9 -0
+}
+
+static inline int kvm__register_ram_guest_memfd(struct kvm *kvm, u64 guest_phys,
+						u64 size, void *userspace_addr,
+						int guest_memfd,
+						u64 guest_memfd_offset)
+{
+	return kvm__register_mem(kvm, guest_phys, size, userspace_addr,
+				 guest_memfd, guest_memfd_offset,
 				 KVM_MEM_TYPE_RAM);

One small nitpick here, KVM_CREATE_GUEST_MEMFD returns -1 on error. If callers forget to check the result of KVM_CREATE_GUEST_MEMFD and pass the result to kvm__register_ram_guest_memfd(), the error won't be detected and kvmtool will end up creating a non-guest_memfd backed memslot. Definitely unexpected. It might be useful to someone, someday, to add a check here for guest_memfd >= 0, but it's not terribly important.

Regardless:

Thanks,
Alex

Quoted 77 lines
include/kvm/kvm.h +2 -2
 }
 
@@ -140,13 +151,13 @@ static inline int kvm__register_dev_mem(struct kvm *kvm, u64 guest_phys,
 					u64 size, void *userspace_addr)
 {
 	return kvm__register_mem(kvm, guest_phys, size, userspace_addr,
-				 KVM_MEM_TYPE_DEVICE);
+				 -1, 0, KVM_MEM_TYPE_DEVICE);
 }
 
 static inline int kvm__reserve_mem(struct kvm *kvm, u64 guest_phys, u64 size)
 {
 	return kvm__register_mem(kvm, guest_phys, size, NULL,
-				 KVM_MEM_TYPE_RESERVED);
+				 -1, 0, KVM_MEM_TYPE_RESERVED);
 }
 
 int __must_check kvm__register_iotrap(struct kvm *kvm, u64 phys_addr, u64 len,
kvm.c +26 -10
index 95ccfcb..947721b 100644
@@ -237,9 +237,9 @@ out:
 }
 
 int kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size,
-		      void *userspace_addr, enum kvm_mem_type type)
+		      void *userspace_addr, int guest_memfd,
+		      u64 guest_memfd_offset, enum kvm_mem_type type)
 {
-	struct kvm_userspace_memory_region mem;
 	struct kvm_mem_bank *merged = NULL;
 	struct kvm_mem_bank *bank;
 	struct list_head *prev_entry;
@@ -320,15 +320,31 @@ int kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size,
 		flags |= KVM_MEM_READONLY;
 
 	if (type != KVM_MEM_TYPE_RESERVED) {
-		mem = (struct kvm_userspace_memory_region) {
-			.slot			= slot,
-			.flags			= flags,
-			.guest_phys_addr	= guest_phys,
-			.memory_size		= size,
-			.userspace_addr		= (unsigned long)userspace_addr,
-		};
+		if (guest_memfd >= 0) {
+			struct kvm_userspace_memory_region2 mem2 = {
+				.slot			= slot,
+				.flags			= flags | KVM_MEM_GUEST_MEMFD,
+				.guest_phys_addr	= guest_phys,
+				.memory_size		= size,
+				.userspace_addr		= (unsigned long)userspace_addr,
+				.guest_memfd		= guest_memfd,
+				.guest_memfd_offset	= guest_memfd_offset,
+			};
 
-		ret = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &mem);
+			ret = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION2,
+				    &mem2);
+		} else {
+			struct kvm_userspace_memory_region mem = {
+				.slot			= slot,
+				.flags			= flags,
+				.guest_phys_addr	= guest_phys,
+				.memory_size		= size,
+				.userspace_addr		= (unsigned long)userspace_addr,
+			};
+
+			ret = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION,
+				    &mem);
+		}
 		if (ret < 0) {
 			ret = -errno;
 			goto out;
Signature · 1 line
2.39.5
author reviewer
#5 lore raw

Re: [PATCH kvmtool v2 3/4] Add support for registering guest_memfd-backed memory regions

Quoted 54 lines · Alexandru Elisei

Hi Fuad,

Quoted 50 lines · Fuad Tabba

Extend kvm__register_mem() with a guest_memfd file descriptor and offset. A bank with a guest_memfd is registered with KVM_SET_USER_MEMORY_REGION2 and KVM_MEM_GUEST_MEMFD, binding the memslot to the file. This prepares for backing guest RAM with guest_memfd on arm64.

---
 hw/cfi_flash.c    |  2 +-
 include/kvm/kvm.h | 15 +++++++++++++--
 kvm.c             | 36 ++++++++++++++++++++++++++----------
 3 files changed, 40 insertions(+), 13 deletions(-)
hw/cfi_flash.c +1 -1
index b68d9e0..4413955 100644
@@ -451,7 +451,7 @@ static int map_flash_memory(struct kvm *kvm, struct cfi_flash_device *sfdev)
      int ret;
 
      ret = kvm__register_mem(kvm, sfdev->base_addr, sfdev->size,
-                             sfdev->flash_memory,
+                             sfdev->flash_memory, -1, 0,
                              KVM_MEM_TYPE_RAM | KVM_MEM_TYPE_READONLY);
      if (!ret)
              sfdev->is_mapped = true;
include/kvm/kvm.h +11 -0
index eb23e2f..5e7b5eb 100644
@@ -128,11 +128,22 @@ bool kvm__emulate_io(struct kvm_cpu *vcpu, u16 port, void *data, int direction,
 bool kvm__emulate_mmio(struct kvm_cpu *vcpu, u64 phys_addr, u8 *data, u32 len, u8 is_write);
 int kvm__destroy_mem(struct kvm *kvm, u64 guest_phys, u64 size, void *userspace_addr);
 int kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size, void *userspace_addr,
+                   int guest_memfd, u64 guest_memfd_offset,
                    enum kvm_mem_type type);
 static inline int kvm__register_ram(struct kvm *kvm, u64 guest_phys, u64 size,
                                  void *userspace_addr)
 {
      return kvm__register_mem(kvm, guest_phys, size, userspace_addr,
+                              -1, 0, KVM_MEM_TYPE_RAM);
+}
+
+static inline int kvm__register_ram_guest_memfd(struct kvm *kvm, u64 guest_phys,
+                                             u64 size, void *userspace_addr,
+                                             int guest_memfd,
+                                             u64 guest_memfd_offset)
+{
+     return kvm__register_mem(kvm, guest_phys, size, userspace_addr,
+                              guest_memfd, guest_memfd_offset,
Quoted 8 lines

include/kvm/kvm.h bool kvm__emulate_io(struct kvm_cpu *vcpu, u16 port, void *data, int direction, · line 147

Quoted 1 line
include/kvm/kvm.h +0 -0
                               KVM_MEM_TYPE_RAM);

One small nitpick here, KVM_CREATE_GUEST_MEMFD returns -1 on error. If callers forget to check the result of KVM_CREATE_GUEST_MEMFD and pass the result to kvm__register_ram_guest_memfd(), the error won't be detected and kvmtool will end up creating a non-guest_memfd backed memslot. Definitely unexpected. It might be useful to someone, someday, to add a check here for guest_memfd >= 0, but it's not terribly important.

Good point. The only caller today (mmap_guest_memfd) already dies on error, but a defensive check in kvm__register_mem makes the contract explicit. I'll add one in v3.

Quoted 3 lines

Regardless:

Thanks!
/fuad

Quoted 81 lines

Thanks,
Alex

Quoted 77 lines
include/kvm/kvm.h +2 -2
 }
 
@@ -140,13 +151,13 @@ static inline int kvm__register_dev_mem(struct kvm *kvm, u64 guest_phys,
                                      u64 size, void *userspace_addr)
 {
      return kvm__register_mem(kvm, guest_phys, size, userspace_addr,
-                              KVM_MEM_TYPE_DEVICE);
+                              -1, 0, KVM_MEM_TYPE_DEVICE);
 }
 
 static inline int kvm__reserve_mem(struct kvm *kvm, u64 guest_phys, u64 size)
 {
      return kvm__register_mem(kvm, guest_phys, size, NULL,
-                              KVM_MEM_TYPE_RESERVED);
+                              -1, 0, KVM_MEM_TYPE_RESERVED);
 }
 
 int __must_check kvm__register_iotrap(struct kvm *kvm, u64 phys_addr, u64 len,
kvm.c +26 -11
index 95ccfcb..947721b 100644
@@ -237,9 +237,9 @@ out:
 }
 
 int kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size,
-                   void *userspace_addr, enum kvm_mem_type type)
+                   void *userspace_addr, int guest_memfd,
+                   u64 guest_memfd_offset, enum kvm_mem_type type)
 {
-     struct kvm_userspace_memory_region mem;
      struct kvm_mem_bank *merged = NULL;
      struct kvm_mem_bank *bank;
      struct list_head *prev_entry;
@@ -320,15 +320,31 @@ int kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size,
              flags |= KVM_MEM_READONLY;
 
      if (type != KVM_MEM_TYPE_RESERVED) {
-             mem = (struct kvm_userspace_memory_region) {
-                     .slot                   = slot,
-                     .flags                  = flags,
-                     .guest_phys_addr        = guest_phys,
-                     .memory_size            = size,
-                     .userspace_addr         = (unsigned long)userspace_addr,
-             };
+             if (guest_memfd >= 0) {
+                     struct kvm_userspace_memory_region2 mem2 = {
+                             .slot                   = slot,
+                             .flags                  = flags | KVM_MEM_GUEST_MEMFD,
+                             .guest_phys_addr        = guest_phys,
+                             .memory_size            = size,
+                             .userspace_addr         = (unsigned long)userspace_addr,
+                             .guest_memfd            = guest_memfd,
+                             .guest_memfd_offset     = guest_memfd_offset,
+                     };
 
-             ret = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &mem);
+                     ret = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION2,
+                                 &mem2);
+             } else {
+                     struct kvm_userspace_memory_region mem = {
+                             .slot                   = slot,
+                             .flags                  = flags,
+                             .guest_phys_addr        = guest_phys,
+                             .memory_size            = size,
+                             .userspace_addr         = (unsigned long)userspace_addr,
+                     };
+
+                     ret = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION,
+                                 &mem);
+             }
              if (ret < 0) {
                      ret = -errno;
                      goto out;
--

2.39.5

author reviewer
#6 lore raw

PATCH v2 4/4 arm64: Add --guest-memfd option to back guest RAM with guest_memfd

In reply to Fuad Tabba

Back guest RAM with a guest_memfd created with GUEST_MEMFD_FLAG_MMAP and GUEST_MEMFD_FLAG_INIT_SHARED, mmapped MAP_SHARED to provide the userspace mapping. The guest_memfd file descriptor is closed at teardown, after the mapping is removed.

Protected VMs need in-place shared/private conversion of guest_memfd, which the kernel does not support yet, so reject the combination of --protected and --guest-memfd.

---
 arm64/include/kvm/kvm-config-arch.h |  5 +++-
 arm64/kvm.c                         | 43 +++++++++++++++++++++++------
 include/kvm/kvm.h                   |  1 +
 include/kvm/util.h                  |  1 +
 kvm.c                               |  1 +
 util/util.c                         | 37 +++++++++++++++++++++++++
 6 files changed, 79 insertions(+), 9 deletions(-)
arm64/include/kvm/kvm-config-arch.h +4 -1
index c2702d5..d8a8ef7 100644
@@ -20,6 +20,7 @@ struct kvm_config_arch {
 	bool		no_pvtime;
 	bool		psci;
 	bool		protected;
+	bool		guest_memfd;
 };
 
 int irqchip_parser(const struct option *opt, const char *arg, int unset);
@@ -73,6 +74,8 @@ int sve_vl_parser(const struct option *opt, const char *arg, int unset);
 	OPT_BOOLEAN('\0', "e2h0", &(cfg)->e2h0,					\
 		    "Create guest without VHE support"),			\
 	OPT_BOOLEAN('\0', "protected", &(cfg)->protected,			\
-			"Create a protected VM when pKVM is enabled"),
+			"Create a protected VM when pKVM is enabled"),		\
+	OPT_BOOLEAN('\0', "guest-memfd", &(cfg)->guest_memfd,			\
+			"Use guest_memfd to back guest RAM"),
 
 #endif /* ARM_COMMON__KVM_CONFIG_ARCH_H */
arm64/kvm.c +35 -8

73 lines not on this page · raw message

include/kvm/kvm.h +1 -0
index 5e7b5eb..95dc52f 100644
@@ -90,6 +90,7 @@ struct kvm {
 	u64			ram_size;	/* Guest memory size, in bytes */
 	void			*ram_start;
 	u64			ram_pagesize;
+	int			ram_guest_memfd; /* guest_memfd backing RAM, -1 if none */
 	struct mutex		mem_banks_lock;
 	struct list_head	mem_banks;
 
include/kvm/util.h +1 -0
index a6dba11..9e23431 100644
@@ -148,5 +148,6 @@ static inline int pow2_size(unsigned long x)
 struct kvm;
 void *mmap_hugetlbfs(struct kvm *kvm, const char *htlbfs_path, u64 size);
 void *mmap_anon_or_hugetlbfs(struct kvm *kvm, const char *hugetlbfs_path, u64 size);
+void *mmap_guest_memfd(struct kvm *kvm, u64 size);
 
 #endif /* KVM__UTIL_H */
kvm.c +1 -0
index 947721b..96583f9 100644
@@ -162,6 +162,7 @@ struct kvm *kvm__new(void)
 	mutex_init(&kvm->mem_banks_lock);
 	kvm->sys_fd = -1;
 	kvm->vm_fd = -1;
+	kvm->ram_guest_memfd = -1;
 
 #ifdef KVM_BRLOCK_DEBUG
 	kvm->brlock_sem = (pthread_rwlock_t) PTHREAD_RWLOCK_INITIALIZER;
util/util.c +37 -0
index 05d49c4..51a4591 100644
@@ -6,7 +6,9 @@
 #include "kvm/util.h"
 
 #include <kvm/kvm.h>
+#include <linux/kvm.h>
 #include <linux/magic.h>	/* For HUGETLBFS_MAGIC */
+#include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/statfs.h>
@@ -169,3 +171,38 @@ void *mmap_anon_or_hugetlbfs(struct kvm *kvm, const char *hugetlbfs_path, u64 si
 		return mmap(NULL, size, PROT_RW, MAP_ANON_NORESERVE, -1, 0);
 	}
 }
+
+/*
+ * Map guest RAM backed by a guest_memfd. The file descriptor is kept open
+ * until teardown (kvm__arch_delete_ram), after the mapping is removed.
+ */
+void *mmap_guest_memfd(struct kvm *kvm, u64 size)
+{
+	u64 flags = GUEST_MEMFD_FLAG_MMAP | GUEST_MEMFD_FLAG_INIT_SHARED;
+	struct kvm_create_guest_memfd gmem = {
+		.size	= size,
+		.flags	= flags,
+	};
+	void *addr;
+	int ret;
+
+	if (!kvm__supports_extension(kvm, KVM_CAP_GUEST_MEMFD))
+		die("kernel does not support guest_memfd");
+
+	ret = ioctl(kvm->vm_fd, KVM_CHECK_EXTENSION, KVM_CAP_GUEST_MEMFD_FLAGS);
+	if (ret < 0 || ((u64)ret & flags) != flags)
+		die("VM type does not support guest_memfd with mmap");
+
+	ret = ioctl(kvm->vm_fd, KVM_CREATE_GUEST_MEMFD, &gmem);
+	if (ret < 0)
+		die_perror("KVM_CREATE_GUEST_MEMFD");
+
+	addr = mmap(NULL, size, PROT_RW, MAP_SHARED, ret, 0);
+	if (addr == MAP_FAILED)
+		die_perror("guest_memfd mmap");
+
+	kvm->ram_guest_memfd = ret;
+	kvm->ram_pagesize = getpagesize();
+
+	return addr;
+}
Signature · 1 line
2.39.5
#7 lore raw

Re: [PATCH kvmtool v2 4/4] arm64: Add --guest-memfd option to back guest RAM with guest_memfd

Hi Fuad,

Quoted 50 lines · Fuad Tabba

Back guest RAM with a guest_memfd created with GUEST_MEMFD_FLAG_MMAP and GUEST_MEMFD_FLAG_INIT_SHARED, mmapped MAP_SHARED to provide the userspace mapping. The guest_memfd file descriptor is closed at teardown, after the mapping is removed.

Protected VMs need in-place shared/private conversion of guest_memfd, which the kernel does not support yet, so reject the combination of --protected and --guest-memfd.

---
 arm64/include/kvm/kvm-config-arch.h |  5 +++-
 arm64/kvm.c                         | 43 +++++++++++++++++++++++------
 include/kvm/kvm.h                   |  1 +
 include/kvm/util.h                  |  1 +
 kvm.c                               |  1 +
 util/util.c                         | 37 +++++++++++++++++++++++++
 6 files changed, 79 insertions(+), 9 deletions(-)
arm64/include/kvm/kvm-config-arch.h +4 -1
index c2702d5..d8a8ef7 100644
@@ -20,6 +20,7 @@ struct kvm_config_arch {
 	bool		no_pvtime;
 	bool		psci;
 	bool		protected;
+	bool		guest_memfd;
 };
 
 int irqchip_parser(const struct option *opt, const char *arg, int unset);
@@ -73,6 +74,8 @@ int sve_vl_parser(const struct option *opt, const char *arg, int unset);
 	OPT_BOOLEAN('\0', "e2h0", &(cfg)->e2h0,					\
 		    "Create guest without VHE support"),			\
 	OPT_BOOLEAN('\0', "protected", &(cfg)->protected,			\
-			"Create a protected VM when pKVM is enabled"),
+			"Create a protected VM when pKVM is enabled"),		\
+	OPT_BOOLEAN('\0', "guest-memfd", &(cfg)->guest_memfd,			\
+			"Use guest_memfd to back guest RAM"),
 
 #endif /* ARM_COMMON__KVM_CONFIG_ARCH_H */
arm64/kvm.c +0 -1
index fb0b98d..bf4e34e 100644
@@ -49,9 +49,14 @@ void kvm__init_ram(struct kvm *kvm)
 	kvm->arch.ram_alloc_size = kvm->ram_size;
 	if (!kvm->cfg.hugetlbfs_path)
 		kvm->arch.ram_alloc_size += SZ_2M;
-	kvm->arch.ram_alloc_start = mmap_anon_or_hugetlbfs(kvm,

arm64/kvm.c void kvm__init_ram(struct kvm *kvm) · line 59

Quoted 10 lines
arm64/kvm.c +8 -2
-						kvm->cfg.hugetlbfs_path,
-						kvm->arch.ram_alloc_size);
+
+	if (kvm->cfg.arch.guest_memfd)
+		kvm->arch.ram_alloc_start =
+			mmap_guest_memfd(kvm, kvm->arch.ram_alloc_size);
+	else
+		kvm->arch.ram_alloc_start =
+			mmap_anon_or_hugetlbfs(kvm, kvm->cfg.hugetlbfs_path,
+					       kvm->arch.ram_alloc_size);

Would you mind not splitting the line after the equal sign? It makes parsing the code really hard (at least for me).

Quoted 48 lines
arm64/kvm.c +18 -5
 	if (kvm->arch.ram_alloc_start == MAP_FAILED)
 		die("Failed to map %lld bytes for guest memory (%d)",
@@ -60,17 +65,25 @@ void kvm__init_ram(struct kvm *kvm)
 	kvm->ram_start = (void *)ALIGN((unsigned long)kvm->arch.ram_alloc_start,
 					SZ_2M);
 
-	madvise(kvm->arch.ram_alloc_start, kvm->arch.ram_alloc_size,
-		MADV_MERGEABLE);
+	if (!kvm->cfg.arch.guest_memfd) {
+		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);
+		madvise(kvm->arch.ram_alloc_start, kvm->arch.ram_alloc_size,
+			MADV_HUGEPAGE);
+	}
 
 	phys_start	= kvm->cfg.ram_addr;
 	phys_size	= kvm->ram_size;
 	host_mem	= kvm->ram_start;
 
-	err = kvm__register_ram(kvm, phys_start, phys_size, host_mem);
+	if (kvm->cfg.arch.guest_memfd)
+		err = kvm__register_ram_guest_memfd(kvm, phys_start,
+						    phys_size, host_mem,
+						    kvm->ram_guest_memfd,
+						    host_mem - kvm->arch.ram_alloc_start);
+	else
+		err = kvm__register_ram(kvm, phys_start, phys_size, host_mem);
 	if (err)
 		die("Failed to register %lld bytes of memory at physical "
 		    "address 0x%llx [err %d]", phys_size, phys_start, err);
@@ -84,6 +97,11 @@ void kvm__init_ram(struct kvm *kvm)
 void kvm__arch_delete_ram(struct kvm *kvm)
 {
 	munmap(kvm->arch.ram_alloc_start, kvm->arch.ram_alloc_size);
+
+	if (kvm->ram_guest_memfd >= 0) {
+		close(kvm->ram_guest_memfd);
+		kvm->ram_guest_memfd = -1;
+	}
 }
 
 void kvm__arch_read_term(struct kvm *kvm)
@@ -468,6 +486,15 @@ void kvm__arch_validate_cfg(struct kvm *kvm)
 	if (kvm->cfg.arch.e2h0 && !kvm->cfg.arch.nested_virt)

arm64/kvm.c void kvm__arch_validate_cfg(struct kvm *kvm) · line 496

Quoted 10 lines
arm64/kvm.c +8 -0
 		pr_warning("--e2h0 requires --nested, ignoring");
 
+	if (kvm->cfg.arch.guest_memfd) {
+		/* Requires in-place shared/private conversion of guest_memfd. */
+		if (kvm->cfg.arch.protected)
+			die("Protected VMs do not yet support guest_memfd");
+
+		if (kvm->cfg.hugetlbfs_path)
+			die("guest_memfd cannot be backed by hugetlbfs");
+	}

I think MTE is incompatible with guest_memfd, KVM certainly returns an error from kvm_arch_prepare_memory_region() when both are set. Since MTE is enabled by default, it might be useful to let the user know that MTE has been disabled because of guest_memfd.

Otherwise, everything looks good.

Thanks,
Alex

Quoted 95 lines
arm64/kvm.c +1 -0
+
 	if (kvm->cfg.arch.protected) {
 		if (kvm->cfg.ram_size &&
 		    kvm->cfg.ram_size < DMA_MEM_REGION_SIZE) {
include/kvm/kvm.h +1 -0
index 5e7b5eb..95dc52f 100644
@@ -90,6 +90,7 @@ struct kvm {
 	u64			ram_size;	/* Guest memory size, in bytes */
 	void			*ram_start;
 	u64			ram_pagesize;
+	int			ram_guest_memfd; /* guest_memfd backing RAM, -1 if none */
 	struct mutex		mem_banks_lock;
 	struct list_head	mem_banks;
 
include/kvm/util.h +1 -0
index a6dba11..9e23431 100644
@@ -148,5 +148,6 @@ static inline int pow2_size(unsigned long x)
 struct kvm;
 void *mmap_hugetlbfs(struct kvm *kvm, const char *htlbfs_path, u64 size);
 void *mmap_anon_or_hugetlbfs(struct kvm *kvm, const char *hugetlbfs_path, u64 size);
+void *mmap_guest_memfd(struct kvm *kvm, u64 size);
 
 #endif /* KVM__UTIL_H */
kvm.c +1 -0
index 947721b..96583f9 100644
@@ -162,6 +162,7 @@ struct kvm *kvm__new(void)
 	mutex_init(&kvm->mem_banks_lock);
 	kvm->sys_fd = -1;
 	kvm->vm_fd = -1;
+	kvm->ram_guest_memfd = -1;
 
 #ifdef KVM_BRLOCK_DEBUG
 	kvm->brlock_sem = (pthread_rwlock_t) PTHREAD_RWLOCK_INITIALIZER;
util/util.c +37 -0
index 05d49c4..51a4591 100644
@@ -6,7 +6,9 @@
 #include "kvm/util.h"
 
 #include <kvm/kvm.h>
+#include <linux/kvm.h>
 #include <linux/magic.h>	/* For HUGETLBFS_MAGIC */
+#include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/statfs.h>
@@ -169,3 +171,38 @@ void *mmap_anon_or_hugetlbfs(struct kvm *kvm, const char *hugetlbfs_path, u64 si
 		return mmap(NULL, size, PROT_RW, MAP_ANON_NORESERVE, -1, 0);
 	}
 }
+
+/*
+ * Map guest RAM backed by a guest_memfd. The file descriptor is kept open
+ * until teardown (kvm__arch_delete_ram), after the mapping is removed.
+ */
+void *mmap_guest_memfd(struct kvm *kvm, u64 size)
+{
+	u64 flags = GUEST_MEMFD_FLAG_MMAP | GUEST_MEMFD_FLAG_INIT_SHARED;
+	struct kvm_create_guest_memfd gmem = {
+		.size	= size,
+		.flags	= flags,
+	};
+	void *addr;
+	int ret;
+
+	if (!kvm__supports_extension(kvm, KVM_CAP_GUEST_MEMFD))
+		die("kernel does not support guest_memfd");
+
+	ret = ioctl(kvm->vm_fd, KVM_CHECK_EXTENSION, KVM_CAP_GUEST_MEMFD_FLAGS);
+	if (ret < 0 || ((u64)ret & flags) != flags)
+		die("VM type does not support guest_memfd with mmap");
+
+	ret = ioctl(kvm->vm_fd, KVM_CREATE_GUEST_MEMFD, &gmem);
+	if (ret < 0)
+		die_perror("KVM_CREATE_GUEST_MEMFD");
+
+	addr = mmap(NULL, size, PROT_RW, MAP_SHARED, ret, 0);
+	if (addr == MAP_FAILED)
+		die_perror("guest_memfd mmap");
+
+	kvm->ram_guest_memfd = ret;
+	kvm->ram_pagesize = getpagesize();
+
+	return addr;
+}
Signature · 1 line
2.39.5
author reviewer
#8 lore raw

Re: [PATCH kvmtool v2 4/4] arm64: Add --guest-memfd option to back guest RAM with guest_memfd

Quoted 59 lines · Alexandru Elisei

Hi Fuad,

Quoted 55 lines · Fuad Tabba

Back guest RAM with a guest_memfd created with GUEST_MEMFD_FLAG_MMAP and GUEST_MEMFD_FLAG_INIT_SHARED, mmapped MAP_SHARED to provide the userspace mapping. The guest_memfd file descriptor is closed at teardown, after the mapping is removed.

Protected VMs need in-place shared/private conversion of guest_memfd, which the kernel does not support yet, so reject the combination of --protected and --guest-memfd.

---
 arm64/include/kvm/kvm-config-arch.h |  5 +++-
 arm64/kvm.c                         | 43 +++++++++++++++++++++++------
 include/kvm/kvm.h                   |  1 +
 include/kvm/util.h                  |  1 +
 kvm.c                               |  1 +
 util/util.c                         | 37 +++++++++++++++++++++++++
 6 files changed, 79 insertions(+), 9 deletions(-)
arm64/include/kvm/kvm-config-arch.h +4 -1
index c2702d5..d8a8ef7 100644
@@ -20,6 +20,7 @@ struct kvm_config_arch {
      bool            no_pvtime;
      bool            psci;
      bool            protected;
+     bool            guest_memfd;
 };
 
 int irqchip_parser(const struct option *opt, const char *arg, int unset);
@@ -73,6 +74,8 @@ int sve_vl_parser(const struct option *opt, const char *arg, int unset);
      OPT_BOOLEAN('\0', "e2h0", &(cfg)->e2h0,                                 \
                  "Create guest without VHE support"),                        \
      OPT_BOOLEAN('\0', "protected", &(cfg)->protected,                       \
-                     "Create a protected VM when pKVM is enabled"),
+                     "Create a protected VM when pKVM is enabled"),          \
+     OPT_BOOLEAN('\0', "guest-memfd", &(cfg)->guest_memfd,                   \
+                     "Use guest_memfd to back guest RAM"),
 
 #endif /* ARM_COMMON__KVM_CONFIG_ARCH_H */
arm64/kvm.c +3 -3
index fb0b98d..bf4e34e 100644
@@ -49,9 +49,14 @@ void kvm__init_ram(struct kvm *kvm)
      kvm->arch.ram_alloc_size = kvm->ram_size;
      if (!kvm->cfg.hugetlbfs_path)
              kvm->arch.ram_alloc_size += SZ_2M;
-     kvm->arch.ram_alloc_start = mmap_anon_or_hugetlbfs(kvm,
-                                             kvm->cfg.hugetlbfs_path,
-                                             kvm->arch.ram_alloc_size);
+
+     if (kvm->cfg.arch.guest_memfd)
+             kvm->arch.ram_alloc_start =
Quoted 8 lines

arm64/kvm.c void kvm__init_ram(struct kvm *kvm) · line 59

Quoted 5 lines
arm64/kvm.c +5 -0
+                     mmap_guest_memfd(kvm, kvm->arch.ram_alloc_size);
+     else
+             kvm->arch.ram_alloc_start =
+                     mmap_anon_or_hugetlbfs(kvm, kvm->cfg.hugetlbfs_path,
+                                            kvm->arch.ram_alloc_size);

Would you mind not splitting the line after the equal sign? It makes parsing the code really hard (at least for me).

Done.

Quoted 51 lines
Quoted 51 lines
arm64/kvm.c +18 -5
      if (kvm->arch.ram_alloc_start == MAP_FAILED)
              die("Failed to map %lld bytes for guest memory (%d)",
@@ -60,17 +65,25 @@ void kvm__init_ram(struct kvm *kvm)
      kvm->ram_start = (void *)ALIGN((unsigned long)kvm->arch.ram_alloc_start,
                                      SZ_2M);
 
-     madvise(kvm->arch.ram_alloc_start, kvm->arch.ram_alloc_size,
-             MADV_MERGEABLE);
+     if (!kvm->cfg.arch.guest_memfd) {
+             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);
+             madvise(kvm->arch.ram_alloc_start, kvm->arch.ram_alloc_size,
+                     MADV_HUGEPAGE);
+     }
 
      phys_start      = kvm->cfg.ram_addr;
      phys_size       = kvm->ram_size;
      host_mem        = kvm->ram_start;
 
-     err = kvm__register_ram(kvm, phys_start, phys_size, host_mem);
+     if (kvm->cfg.arch.guest_memfd)
+             err = kvm__register_ram_guest_memfd(kvm, phys_start,
+                                                 phys_size, host_mem,
+                                                 kvm->ram_guest_memfd,
+                                                 host_mem - kvm->arch.ram_alloc_start);
+     else
+             err = kvm__register_ram(kvm, phys_start, phys_size, host_mem);
      if (err)
              die("Failed to register %lld bytes of memory at physical "
                  "address 0x%llx [err %d]", phys_size, phys_start, err);
@@ -84,6 +97,11 @@ void kvm__init_ram(struct kvm *kvm)
 void kvm__arch_delete_ram(struct kvm *kvm)
 {
      munmap(kvm->arch.ram_alloc_start, kvm->arch.ram_alloc_size);
+
+     if (kvm->ram_guest_memfd >= 0) {
+             close(kvm->ram_guest_memfd);
+             kvm->ram_guest_memfd = -1;
+     }
 }
 
 void kvm__arch_read_term(struct kvm *kvm)
@@ -468,6 +486,15 @@ void kvm__arch_validate_cfg(struct kvm *kvm)
      if (kvm->cfg.arch.e2h0 && !kvm->cfg.arch.nested_virt)
              pr_warning("--e2h0 requires --nested, ignoring");
 
Quoted 13 lines

arm64/kvm.c void kvm__arch_validate_cfg(struct kvm *kvm) · line 496

Quoted 8 lines
arm64/kvm.c +8 -0
+     if (kvm->cfg.arch.guest_memfd) {
+             /* Requires in-place shared/private conversion of guest_memfd. */
+             if (kvm->cfg.arch.protected)
+                     die("Protected VMs do not yet support guest_memfd");
+
+             if (kvm->cfg.hugetlbfs_path)
+                     die("guest_memfd cannot be backed by hugetlbfs");
+     }

I think MTE is incompatible with guest_memfd, KVM certainly returns an error from kvm_arch_prepare_memory_region() when both are set. Since MTE is enabled by default, it might be useful to let the user know that MTE has been disabled because of guest_memfd.

You're right, VMAs don't get VM_MTE_ALLOWED, so kvm_arch_prepare_memory_region rejects the memslot when MTE is enabled.

I'll disable MTE when --guest-memfd is used, with a message to let the user know.

Cheers,
/fuad

Quoted 101 lines

Otherwise, everything looks good.

Thanks,
Alex

Quoted 95 lines
arm64/kvm.c +1 -0
+
      if (kvm->cfg.arch.protected) {
              if (kvm->cfg.ram_size &&
                  kvm->cfg.ram_size < DMA_MEM_REGION_SIZE) {
include/kvm/kvm.h +1 -0
index 5e7b5eb..95dc52f 100644
@@ -90,6 +90,7 @@ struct kvm {
      u64                     ram_size;       /* Guest memory size, in bytes */
      void                    *ram_start;
      u64                     ram_pagesize;
+     int                     ram_guest_memfd; /* guest_memfd backing RAM, -1 if none */
      struct mutex            mem_banks_lock;
      struct list_head        mem_banks;
 
include/kvm/util.h +1 -0
index a6dba11..9e23431 100644
@@ -148,5 +148,6 @@ static inline int pow2_size(unsigned long x)
 struct kvm;
 void *mmap_hugetlbfs(struct kvm *kvm, const char *htlbfs_path, u64 size);
 void *mmap_anon_or_hugetlbfs(struct kvm *kvm, const char *hugetlbfs_path, u64 size);
+void *mmap_guest_memfd(struct kvm *kvm, u64 size);
 
 #endif /* KVM__UTIL_H */
kvm.c +1 -0
index 947721b..96583f9 100644
@@ -162,6 +162,7 @@ struct kvm *kvm__new(void)
      mutex_init(&kvm->mem_banks_lock);
      kvm->sys_fd = -1;
      kvm->vm_fd = -1;
+     kvm->ram_guest_memfd = -1;
 
 #ifdef KVM_BRLOCK_DEBUG
      kvm->brlock_sem = (pthread_rwlock_t) PTHREAD_RWLOCK_INITIALIZER;
util/util.c +37 -1
index 05d49c4..51a4591 100644
@@ -6,7 +6,9 @@
 #include "kvm/util.h"
 
 #include <kvm/kvm.h>
+#include <linux/kvm.h>
 #include <linux/magic.h>     /* For HUGETLBFS_MAGIC */
+#include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/statfs.h>
@@ -169,3 +171,38 @@ void *mmap_anon_or_hugetlbfs(struct kvm *kvm, const char *hugetlbfs_path, u64 si
              return mmap(NULL, size, PROT_RW, MAP_ANON_NORESERVE, -1, 0);
      }
 }
+
+/*
+ * Map guest RAM backed by a guest_memfd. The file descriptor is kept open
+ * until teardown (kvm__arch_delete_ram), after the mapping is removed.
+ */
+void *mmap_guest_memfd(struct kvm *kvm, u64 size)
+{
+     u64 flags = GUEST_MEMFD_FLAG_MMAP | GUEST_MEMFD_FLAG_INIT_SHARED;
+     struct kvm_create_guest_memfd gmem = {
+             .size   = size,
+             .flags  = flags,
+     };
+     void *addr;
+     int ret;
+
+     if (!kvm__supports_extension(kvm, KVM_CAP_GUEST_MEMFD))
+             die("kernel does not support guest_memfd");
+
+     ret = ioctl(kvm->vm_fd, KVM_CHECK_EXTENSION, KVM_CAP_GUEST_MEMFD_FLAGS);
+     if (ret < 0 || ((u64)ret & flags) != flags)
+             die("VM type does not support guest_memfd with mmap");
+
+     ret = ioctl(kvm->vm_fd, KVM_CREATE_GUEST_MEMFD, &gmem);
+     if (ret < 0)
+             die_perror("KVM_CREATE_GUEST_MEMFD");
+
+     addr = mmap(NULL, size, PROT_RW, MAP_SHARED, ret, 0);
+     if (addr == MAP_FAILED)
+             die_perror("guest_memfd mmap");
+
+     kvm->ram_guest_memfd = ret;
+     kvm->ram_pagesize = getpagesize();
+
+     return addr;
+}
--

2.39.5