From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4488DC5AE59 for ; Thu, 5 Jun 2025 22:08:01 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id A29CA6B0092; Thu, 5 Jun 2025 18:08:00 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 9DA366B00CF; Thu, 5 Jun 2025 18:08:00 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 8A2746B00D0; Thu, 5 Jun 2025 18:08:00 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0013.hostedemail.com [216.40.44.13]) by kanga.kvack.org (Postfix) with ESMTP id 643396B0092 for ; Thu, 5 Jun 2025 18:08:00 -0400 (EDT) Received: from smtpin03.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay03.hostedemail.com (Postfix) with ESMTP id 0FCE4BF418 for ; Thu, 5 Jun 2025 22:08:00 +0000 (UTC) X-FDA: 83522735520.03.F935D40 Received: from mail-yb1-f182.google.com (mail-yb1-f182.google.com [209.85.219.182]) by imf03.hostedemail.com (Postfix) with ESMTP id 2CEDC20013 for ; Thu, 5 Jun 2025 22:07:58 +0000 (UTC) Authentication-Results: imf03.hostedemail.com; dkim=pass header.d=google.com header.s=20230601 header.b=UqxKBAcp; spf=pass (imf03.hostedemail.com: domain of jthoughton@google.com designates 209.85.219.182 as permitted sender) smtp.mailfrom=jthoughton@google.com; dmarc=pass (policy=reject) header.from=google.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1749161278; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=CnKZWTFx1r/r3bpI9eHGqslLc1oESYCbSdxu/x7viwQ=; b=0L5ryphfB0o3sv6N8L3QwrpZ9drqN3iMdfWQZW3JuluwFmUNnIemk1rRqtE8t9AD98jq1A kG4UrU9VHJ63BBy2gZfdtBB6JacXX+PNNtPxNKMLP4lVBLT4JuMU02d6Ap7V9Pc2YTU2qf h9CMmv0bd+F5O5BulC2ViOHyJ1Nh6PU= ARC-Authentication-Results: i=1; imf03.hostedemail.com; dkim=pass header.d=google.com header.s=20230601 header.b=UqxKBAcp; spf=pass (imf03.hostedemail.com: domain of jthoughton@google.com designates 209.85.219.182 as permitted sender) smtp.mailfrom=jthoughton@google.com; dmarc=pass (policy=reject) header.from=google.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1749161278; a=rsa-sha256; cv=none; b=3Wpkq7WVv/LTz0OVHZ4MjKU3mbb2ah/Bnq+l4Fo83ujSQR+yHZP4f3w/FE8XZn2uiwX9o7 7bB0mNQbrxukks1BZufFggG1/6/ywxzPFQ5EXAD7/Wm0t85isndW/qrgyC+c9akc7fXBVm 9ns7yjIU16XR14wyX/R7LtUHq5KGxAc= Received: by mail-yb1-f182.google.com with SMTP id 3f1490d57ef6-e733a6ff491so1621268276.2 for ; Thu, 05 Jun 2025 15:07:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1749161277; x=1749766077; darn=kvack.org; h=content-transfer-encoding:cc:to:subject:message-id:date:from :in-reply-to:references:mime-version:from:to:cc:subject:date :message-id:reply-to; bh=CnKZWTFx1r/r3bpI9eHGqslLc1oESYCbSdxu/x7viwQ=; b=UqxKBAcpa4nlCnmdiE44WG41JRhEEf9e8fH4nNNjiLil8JU7tAEGjga3Lj9caMBRBH Go2Z3Jg3oicNqIicUjdCp4qldg3Wh+Nk8/5CRarNaMNxRHaaSvKRo7IhZQtzoZf5eDyj EdROU0WfiTBk5zyu0SDGwdZCnPmLDONOn7UIM51l0/mtyCNuJWe6uFexT49O1jqVhWfM jodT9XtYMWsCitLjzBrkPyc2/vDNRU8m3nv0zv3lC359WvNaozya/mL7YFfoFgvwuHPV rjtRchLIM5JpcEEWxfU0X11B2j5HTE2b+6DLMLj2N4Wq16gBoExQqpsoz2xs/xtDesp4 kXSg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1749161277; x=1749766077; h=content-transfer-encoding:cc:to:subject:message-id:date:from :in-reply-to:references:mime-version:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=CnKZWTFx1r/r3bpI9eHGqslLc1oESYCbSdxu/x7viwQ=; b=hl2sZ2SkINpEWQzLerjJvlfuucAQRR1IMeEjoj/qaGK7zaxvtf0q66d4lygvuJR6oS E3IjK93LhI4K9VwA7suhtJdIrtHdUbA5MKcOegN6MLuJddKzCVN1ADope/+4+ysO7Wpy niQ7Y/yAAlQ96xDH4POSltdisRG5Gp+ZMaUGefNEIbE1nOw+V3qmWvI+0Oa1wwJ1sdjv O9tYiBoiK5JEQyCWmh1y7VIezPFAMfVFlO8TtL/B6QDF444jPGeTRolVHcM8OAK2DONn 43ylqL8OZ1o1l/zeKPK+KnpBeBfJiDakm6LoJUE+NHEAywdEX96JOaIFY1PEaYaXVD18 VWtA== X-Forwarded-Encrypted: i=1; AJvYcCXwaIbXjvWvrnwbSUexfjwplnwNMlB68J3OwRUaPLeFQnzHKQnNQIYRFXllQPX75oG0Ej3DSWXV3A==@kvack.org X-Gm-Message-State: AOJu0Yyan3RY0o22JHoZTTJm+D4OZlCLQjonZbfFF6lmpl3w3bAuC+pu Idt5MksOS8Lxa8AE7/tyLBBl29ujygQXfkJo/g6DuDN1gC0IabC41PHbigxddgm3elrPqTsNmAg li/oR2eC9l57B6oMZykPhEVrMkDXGoBbCIkkxZ/mO X-Gm-Gg: ASbGnctciKesmfIBrhVPXEIWwBjeZ8uPWgjXaqMxR+bIF/iDGGlL7HAV0ZjHu8unGNy mr4wsBV1Tj/NWFMY8nbF2nNF/jDm+YuaJnXFwXsNnRJUSuIrKTdKVCioxR1hyzYVA4lF3Dghft+ TBTf680ns1rAcNsJTYN77W6QqMzR4Pu8BgwDAaJbg9RpxRynKJiQV7bHrAStzZ9+p8t+hQp0sV X-Google-Smtp-Source: AGHT+IGq7lMGRK6rP20ELHAYuEiLr4LmheLkErrPUhfTNANU8S4aRAPfjJb3nPfn3laHUFkxC0Uyfu14q15f8dlPRus= X-Received: by 2002:a05:6902:220b:b0:e7f:7352:bb30 with SMTP id 3f1490d57ef6-e81a229b8d4mr2096060276.18.1749161274959; Thu, 05 Jun 2025 15:07:54 -0700 (PDT) MIME-Version: 1.0 References: <20250605153800.557144-1-tabba@google.com> <20250605153800.557144-19-tabba@google.com> In-Reply-To: <20250605153800.557144-19-tabba@google.com> From: James Houghton Date: Thu, 5 Jun 2025 15:07:19 -0700 X-Gm-Features: AX0GCFvZGdmOFMM-9Yc-PlTUSLHYGP-h7M0hdxQXdKrebyonS61n3MScTO4Qlao Message-ID: Subject: Re: [PATCH v11 18/18] KVM: selftests: guest_memfd mmap() test when mapping is allowed To: Fuad Tabba Cc: kvm@vger.kernel.org, linux-arm-msm@vger.kernel.org, linux-mm@kvack.org, kvmarm@lists.linux.dev, pbonzini@redhat.com, chenhuacai@kernel.org, mpe@ellerman.id.au, anup@brainfault.org, paul.walmsley@sifive.com, palmer@dabbelt.com, aou@eecs.berkeley.edu, seanjc@google.com, viro@zeniv.linux.org.uk, brauner@kernel.org, willy@infradead.org, akpm@linux-foundation.org, xiaoyao.li@intel.com, yilun.xu@intel.com, chao.p.peng@linux.intel.com, jarkko@kernel.org, amoorthy@google.com, dmatlack@google.com, isaku.yamahata@intel.com, mic@digikod.net, vbabka@suse.cz, vannapurve@google.com, ackerleytng@google.com, mail@maciej.szmigiero.name, david@redhat.com, michael.roth@amd.com, wei.w.wang@intel.com, liam.merwick@oracle.com, isaku.yamahata@gmail.com, kirill.shutemov@linux.intel.com, suzuki.poulose@arm.com, steven.price@arm.com, quic_eberman@quicinc.com, quic_mnalajal@quicinc.com, quic_tsoni@quicinc.com, quic_svaddagi@quicinc.com, quic_cvanscha@quicinc.com, quic_pderrin@quicinc.com, quic_pheragu@quicinc.com, catalin.marinas@arm.com, james.morse@arm.com, yuzenghui@huawei.com, oliver.upton@linux.dev, maz@kernel.org, will@kernel.org, qperret@google.com, keirf@google.com, roypat@amazon.co.uk, shuah@kernel.org, hch@infradead.org, jgg@nvidia.com, rientjes@google.com, jhubbard@nvidia.com, fvdl@google.com, hughd@google.com, peterx@redhat.com, pankaj.gupta@amd.com, ira.weiny@intel.com Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable X-Rspamd-Queue-Id: 2CEDC20013 X-Stat-Signature: 3a6prehts6dsggbbf5b4ftrayjoekro5 X-Rspam-User: X-Rspamd-Server: rspam07 X-HE-Tag: 1749161278-466598 X-HE-Meta: U2FsdGVkX18oR6NkSuE2waHPEBWVsJ4R6t8upbgYDUMx514pXYTkrDwOFYDNUQTur4jRjOEljbuUfMDpW5gL+8WgJW74FyeNwkdOVAcnOtYidy0vHTfpkguzFH9E+stvq0fH93EGUrMEarSUa8iVvFKoWKYlt6CjvUs8YIscbt0fMsEFNONvxNjPnbOxAbPRu8qaXTWUz7FaEO6EosekkuOQQNsoQmlLi/rUtUyohLnVlnBo6hJ+nyvJRp1GAkAzf9YCPpJbFeKTEhkDQQPrSyAK3DiAwV/ZyK2ghdMKROqFeDJxAgYDyAZLNbENqR4WAsXUdrPVGqYXkjURAJcdg6Si3cNFTDtBiXauP5EdgEFHx+wd9sqEfCv9zSC/NQzJQgnqAPOkB/tVi4OEUqPP1Rvn3al/TcEk7Dc9nSyQe5RqVUexfOH3Ijt7d3JyLBN2YD5mT5yuQHZcNBJ1FXfXGYekJ8JSzJKU+eAWnGzgvP74XWsnUHrNCcZ7E4ufKpLCNfgeCK4lhNhNXzH0kufBAYaX/nHHA2TqvYrPcOSzQfn+voZIdpHzRWsnZtNRBfx3rN1/xejChgvkLTkum8OkOkw3s+H+qC/OQ2qYwUabmxcQinzBGHw4ceWUKpQkDchL+eb9gU3LijjNDkUBIV5cDx8maEPO/BOlwYRQoQCaHFY41HAoESPjUJ1SiYoryfJaazsjwCzeL/MURQMJpvQ4Ke0BB6t7EA9ZbsqJITWxK98QZeZBMcQs871VCRWRMO2h//Fa1+SCjd4U7rRk4gVdj3fLNC0v5Y4A0KGyEJx+NJSuez9qLUMip6Jal8RevNp6Aoh7j+m8HfWqG8M19KR6rhSxJGeeVxkJiveT8cvcSkzpz+CSUnpdWueZhicDBEAi0j88e1QApfA6UwZIOG6iJKUNtHcFYVye1ms8WR96Lf5LWdGTF9ZRVpPOfHBfbJ8dX0nnjGElevqwAT0nYZp Io4tb2G3 xttqMJ3Bx+5QkjPgMsr0IZK9QGNRwaa7oDcb7k+O0FoM/OMvyNtMUndn12wq/AbjLeoKsWsEe5F6xCZIOo5MJpECxOx2wv0vE/A+JqPnGhpsfFss38gyno/pUIr+g4bNeWhNN6dB8l2byY8StggBlHjxh1I8o/Uz9AMIg/2orDOZchR2YkWlNHTq4s4HQpSiQvkBo51KwOOr4y61+skAJWgcgsPeYxPoQy+jWK3UJYu9ayv7Ul9qYpMLPM2DkmAqVueZGne8P4+BpWnbZ/qu+/lm/UN4NL6PiAsSpuX3vUZlmfMYgTeCakKnJ62Z/6rkm/eT9XSDZWRk3THyNior9hvWE+msgcDqfBojvk+uziuD6MJHq43RGL6E7ikX4Fk60HAkmKMfrIpJd12k= X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: On Thu, Jun 5, 2025 at 8:38=E2=80=AFAM Fuad Tabba wrote: > > Expand the guest_memfd selftests to include testing mapping guest > memory for VM types that support it. > > Co-developed-by: Ackerley Tng > Signed-off-by: Ackerley Tng > Signed-off-by: Fuad Tabba Feel free to add: Reviewed-by: James Houghton > --- > .../testing/selftests/kvm/guest_memfd_test.c | 201 ++++++++++++++++-- > 1 file changed, 180 insertions(+), 21 deletions(-) > > diff --git a/tools/testing/selftests/kvm/guest_memfd_test.c b/tools/testi= ng/selftests/kvm/guest_memfd_test.c > index 341ba616cf55..1612d3adcd0d 100644 > --- a/tools/testing/selftests/kvm/guest_memfd_test.c > +++ b/tools/testing/selftests/kvm/guest_memfd_test.c > @@ -13,6 +13,8 @@ > > #include > #include > +#include > +#include > #include > #include > #include > @@ -34,12 +36,83 @@ static void test_file_read_write(int fd) > "pwrite on a guest_mem fd should fail"); > } > > -static void test_mmap(int fd, size_t page_size) > +static void test_mmap_supported(int fd, size_t page_size, size_t total_s= ize) > +{ > + const char val =3D 0xaa; > + char *mem; This must be `volatile char *` to ensure that the compiler doesn't elide the accesses you have written. > + size_t i; > + int ret; > + > + mem =3D mmap(NULL, total_size, PROT_READ | PROT_WRITE, MAP_PRIVAT= E, fd, 0); > + TEST_ASSERT(mem =3D=3D MAP_FAILED, "Copy-on-write not allowed by = guest_memfd."); > + > + mem =3D mmap(NULL, total_size, PROT_READ | PROT_WRITE, MAP_SHARED= , fd, 0); > + TEST_ASSERT(mem !=3D MAP_FAILED, "mmap() for shared guest memory = should succeed."); > + > + memset(mem, val, total_size); Now unfortunately, `memset` and `munmap` will complain about the volatile qualification. So... memset((char *)mem, val, total_size); Eh... wish they just wouldn't complain, but this is a small price to pay for correctness. :) > + for (i =3D 0; i < total_size; i++) > + TEST_ASSERT_EQ(mem[i], val); The compiler is allowed to[1] elide the read of `mem[i]` and just assume that it is `val`. [1]: https://godbolt.org/z/Wora54bP6 Feel free to add `volatile` to that snippet to see how the code changes. > + > + ret =3D fallocate(fd, FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE,= 0, > + page_size); > + TEST_ASSERT(!ret, "fallocate the first page should succeed."); > + > + for (i =3D 0; i < page_size; i++) > + TEST_ASSERT_EQ(mem[i], 0x00); > + for (; i < total_size; i++) > + TEST_ASSERT_EQ(mem[i], val); > + > + memset(mem, val, page_size); > + for (i =3D 0; i < total_size; i++) > + TEST_ASSERT_EQ(mem[i], val); > + > + ret =3D munmap(mem, total_size); > + TEST_ASSERT(!ret, "munmap() should succeed."); > +} > + > +static sigjmp_buf jmpbuf; > +void fault_sigbus_handler(int signum) > +{ > + siglongjmp(jmpbuf, 1); > +} > + > +static void test_fault_overflow(int fd, size_t page_size, size_t total_s= ize) > +{ > + struct sigaction sa_old, sa_new =3D { > + .sa_handler =3D fault_sigbus_handler, > + }; > + size_t map_size =3D total_size * 4; > + const char val =3D 0xaa; > + char *mem; `volatile` here as well. > + size_t i; > + int ret; > + > + mem =3D mmap(NULL, map_size, PROT_READ | PROT_WRITE, MAP_SHARED, = fd, 0); > + TEST_ASSERT(mem !=3D MAP_FAILED, "mmap() for shared guest memory = should succeed."); > + > + sigaction(SIGBUS, &sa_new, &sa_old); > + if (sigsetjmp(jmpbuf, 1) =3D=3D 0) { > + memset(mem, 0xaa, map_size); > + TEST_ASSERT(false, "memset() should have triggered SIGBUS= ."); > + } > + sigaction(SIGBUS, &sa_old, NULL); > + > + for (i =3D 0; i < total_size; i++) > + TEST_ASSERT_EQ(mem[i], val); > + > + ret =3D munmap(mem, map_size); > + TEST_ASSERT(!ret, "munmap() should succeed."); > +} > + > +static void test_mmap_not_supported(int fd, size_t page_size, size_t tot= al_size) > { > char *mem; > > mem =3D mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED,= fd, 0); > TEST_ASSERT_EQ(mem, MAP_FAILED); > + > + mem =3D mmap(NULL, total_size, PROT_READ | PROT_WRITE, MAP_SHARED= , fd, 0); > + TEST_ASSERT_EQ(mem, MAP_FAILED); > } > > static void test_file_size(int fd, size_t page_size, size_t total_size) > @@ -120,26 +193,19 @@ static void test_invalid_punch_hole(int fd, size_t = page_size, size_t total_size) > } > } > > -static void test_create_guest_memfd_invalid(struct kvm_vm *vm) > +static void test_create_guest_memfd_invalid_sizes(struct kvm_vm *vm, > + uint64_t guest_memfd_fl= ags, > + size_t page_size) > { > - size_t page_size =3D getpagesize(); > - uint64_t flag; > size_t size; > int fd; > > for (size =3D 1; size < page_size; size++) { > - fd =3D __vm_create_guest_memfd(vm, size, 0); > - TEST_ASSERT(fd =3D=3D -1 && errno =3D=3D EINVAL, > + fd =3D __vm_create_guest_memfd(vm, size, guest_memfd_flag= s); > + TEST_ASSERT(fd < 0 && errno =3D=3D EINVAL, > "guest_memfd() with non-page-aligned page siz= e '0x%lx' should fail with EINVAL", > size); > } > - > - for (flag =3D BIT(0); flag; flag <<=3D 1) { > - fd =3D __vm_create_guest_memfd(vm, page_size, flag); > - TEST_ASSERT(fd =3D=3D -1 && errno =3D=3D EINVAL, > - "guest_memfd() with flag '0x%lx' should fail = with EINVAL", > - flag); > - } > } > > static void test_create_guest_memfd_multiple(struct kvm_vm *vm) > @@ -171,30 +237,123 @@ static void test_create_guest_memfd_multiple(struc= t kvm_vm *vm) > close(fd1); > } > > -int main(int argc, char *argv[]) > +static bool check_vm_type(unsigned long vm_type) > { > - size_t page_size; > + /* > + * Not all architectures support KVM_CAP_VM_TYPES. However, those= that > + * support guest_memfd have that support for the default VM type. > + */ > + if (vm_type =3D=3D VM_TYPE_DEFAULT) > + return true; > + > + return kvm_check_cap(KVM_CAP_VM_TYPES) & BIT(vm_type); > +} > + > +static void test_with_type(unsigned long vm_type, uint64_t guest_memfd_f= lags, > + bool expect_mmap_allowed) > +{ > + struct kvm_vm *vm; > size_t total_size; > + size_t page_size; > int fd; > - struct kvm_vm *vm; > > - TEST_REQUIRE(kvm_has_cap(KVM_CAP_GUEST_MEMFD)); > + if (!check_vm_type(vm_type)) > + return; > > page_size =3D getpagesize(); > total_size =3D page_size * 4; > > - vm =3D vm_create_barebones(); > + vm =3D vm_create_barebones_type(vm_type); > > - test_create_guest_memfd_invalid(vm); > test_create_guest_memfd_multiple(vm); > + test_create_guest_memfd_invalid_sizes(vm, guest_memfd_flags, page= _size); > > - fd =3D vm_create_guest_memfd(vm, total_size, 0); > + fd =3D vm_create_guest_memfd(vm, total_size, guest_memfd_flags); > > test_file_read_write(fd); > - test_mmap(fd, page_size); > + > + if (expect_mmap_allowed) { > + test_mmap_supported(fd, page_size, total_size); > + test_fault_overflow(fd, page_size, total_size); > + > + } else { > + test_mmap_not_supported(fd, page_size, total_size); > + } > + > test_file_size(fd, page_size, total_size); > test_fallocate(fd, page_size, total_size); > test_invalid_punch_hole(fd, page_size, total_size); > > close(fd); > + kvm_vm_release(vm); I think kvm_vm_free() is probably more appropriate? > +} > + > +static void test_vm_type_gmem_flag_validity(unsigned long vm_type, > + uint64_t expected_valid_flags= ) > +{ > + size_t page_size =3D getpagesize(); > + struct kvm_vm *vm; > + uint64_t flag =3D 0; > + int fd; > + > + if (!check_vm_type(vm_type)) > + return; > + > + vm =3D vm_create_barebones_type(vm_type); > + > + for (flag =3D BIT(0); flag; flag <<=3D 1) { > + fd =3D __vm_create_guest_memfd(vm, page_size, flag); > + > + if (flag & expected_valid_flags) { > + TEST_ASSERT(fd >=3D 0, > + "guest_memfd() with flag '0x%lx' shou= ld be valid", > + flag); > + close(fd); > + } else { > + TEST_ASSERT(fd < 0 && errno =3D=3D EINVAL, > + "guest_memfd() with flag '0x%lx' shou= ld fail with EINVAL", > + flag); > + } > + } > + > + kvm_vm_release(vm); Same here. > +} > + > +static void test_gmem_flag_validity(void) > +{ > + uint64_t non_coco_vm_valid_flags =3D 0; > + > + if (kvm_has_cap(KVM_CAP_GMEM_SHARED_MEM)) > + non_coco_vm_valid_flags =3D GUEST_MEMFD_FLAG_SUPPORT_SHAR= ED; > + > + test_vm_type_gmem_flag_validity(VM_TYPE_DEFAULT, non_coco_vm_vali= d_flags); > + > +#ifdef __x86_64__ > + test_vm_type_gmem_flag_validity(KVM_X86_SW_PROTECTED_VM, non_coco= _vm_valid_flags); > + test_vm_type_gmem_flag_validity(KVM_X86_SEV_VM, 0); > + test_vm_type_gmem_flag_validity(KVM_X86_SEV_ES_VM, 0); > + test_vm_type_gmem_flag_validity(KVM_X86_SNP_VM, 0); > + test_vm_type_gmem_flag_validity(KVM_X86_TDX_VM, 0); > +#endif > +} > + > +int main(int argc, char *argv[]) > +{ > + TEST_REQUIRE(kvm_has_cap(KVM_CAP_GUEST_MEMFD)); > + > + test_gmem_flag_validity(); > + > + test_with_type(VM_TYPE_DEFAULT, 0, false); > + if (kvm_has_cap(KVM_CAP_GMEM_SHARED_MEM)) { > + test_with_type(VM_TYPE_DEFAULT, GUEST_MEMFD_FLAG_SUPPORT_= SHARED, > + true); > + } > + > +#ifdef __x86_64__ > + test_with_type(KVM_X86_SW_PROTECTED_VM, 0, false); > + if (kvm_has_cap(KVM_CAP_GMEM_SHARED_MEM)) { > + test_with_type(KVM_X86_SW_PROTECTED_VM, > + GUEST_MEMFD_FLAG_SUPPORT_SHARED, true); > + } > +#endif > } > -- > 2.49.0.1266.g31b7d2e469-goog >