[PATCH v12] x86/tdx: Fix set_memory_decrypted() for vmalloc() buff=

[Dexuan Cui]

When a TD mode Linux TDX VM runs on Hyper-V, the Linux hv_netvsc driver
needs to share a vmalloc()'d  buffer with the host OS: see
netvsc_init_buf() -> vmbus_establish_gpadl() -> ... ->
__vmbus_establish_gpadl() -> set_memory_decrypted().

Currently set_memory_decrypted() doesn't work for a vmalloc()'d  buffer
because tdx_enc_status_changed() uses __pa(vaddr), i.e., it assumes that
the 'vaddr' can't be from vmalloc(), and consequently hv_netvsc fails
to load.

Fix this by handling the pages one by one.

hv_netvsc is the first user of vmalloc() + set_memory_decrypted(), which
is why nobody noticed this until now.

Co-developed-by: Kirill A. Shutemov <kirill.shutemov@xxxxxxxxxxxxxxx>
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@xxxxxxxxxxxxxxx>
Signed-off-by: Dexuan Cui <decui@xxxxxxxxxxxxx>
Signed-off-by: Dave Hansen <dave.hansen@xxxxxxxxxxxxxxx>
Reviewed-by: Michael Kelley <mikelley@xxxxxxxxxxxxx>
Reviewed-by: Kuppuswamy Sathyanarayanan <sathyanarayanan.kuppuswamy@linux.i=
ntel.com>
Reviewed-by: Rick Edgecombe <rick.p.edgecombe@xxxxxxxxx>
Reviewed-by: Dave Hansen <dave.hansen@xxxxxxxxxxxxxxx>
Acked-by: Kai Huang <kai.huang@xxxxxxxxx>
Cc: stable@xxxxxxxxxxxxxxx # 6.6+
---
 arch/x86/coco/tdx/tdx.c | 43 ++++++++++++++++++++++++++++++++++-------
 1 file changed, 36 insertions(+), 7 deletions(-)

diff --git a/arch/x86/coco/tdx/tdx.c b/arch/x86/coco/tdx/tdx.c
index 078e2bac25531..8f471260924f7 100644
--- a/arch/x86/coco/tdx/tdx.c
+++ b/arch/x86/coco/tdx/tdx.c
@@ -8,6 +8,7 @@
 #include <linux/export.h>
 #include <linux/io.h>
 #include <linux/kexec.h>
+#include <linux/mm.h>
 #include <asm/coco.h>
 #include <asm/tdx.h>
 #include <asm/vmx.h>
@@ -782,6 +783,19 @@ static bool tdx_map_gpa(phys_addr_t start, phys_addr_t=
 end, bool enc)
 	return false;
 }
=20
+static bool tdx_enc_status_changed_phys(phys_addr_t start, phys_addr_t end=
,
+					bool enc)
+{
+	if (!tdx_map_gpa(start, end, enc))
+		return false;
+
+	/* shared->private conversion requires memory to be accepted before use *=
/
+	if (enc)
+		return tdx_accept_memory(start, end);
+
+	return true;
+}
+
 /*
  * Inform the VMM of the guest's intent for this physical page: shared wit=
h
  * the VMM or private to the guest.  The VMM is expected to change its map=
ping
@@ -789,15 +803,30 @@ static bool tdx_map_gpa(phys_addr_t start, phys_addr_=
t end, bool enc)
  */
 static bool tdx_enc_status_changed(unsigned long vaddr, int numpages, bool=
 enc)
 {
-	phys_addr_t start =3D __pa(vaddr);
-	phys_addr_t end   =3D __pa(vaddr + numpages * PAGE_SIZE);
+	unsigned long start =3D vaddr;
+	unsigned long end =3D start + numpages * PAGE_SIZE;
+	unsigned long step =3D end - start;
+	unsigned long addr;
+
+	/* Step through page-by-page for vmalloc() mappings */
+	if (is_vmalloc_addr((void *)vaddr))
+		step =3D PAGE_SIZE;
+
+	for (addr =3D start; addr < end; addr +=3D step) {
+		phys_addr_t start_pa;
+		phys_addr_t end_pa;
+
+		/* The check fails on vmalloc() mappings */
+		if (virt_addr_valid(addr))
+			start_pa =3D __pa(addr);
+		else
+			start_pa =3D slow_virt_to_phys((void *)addr);
=20
-	if (!tdx_map_gpa(start, end, enc))
-		return false;
+		end_pa =3D start_pa + step;
=20
-	/* shared->private conversion requires memory to be accepted before use *=
/
-	if (enc)
-		return tdx_accept_memory(start, end);
+		if (!tdx_enc_status_changed_phys(start_pa, end_pa, enc))
+			return false;
+	}
=20
 	return true;
 }
--=20
2.25.1


--_002_SA1PR21MB1317816DFCE6EF38A92CF254BFDA2SA1PR21MB1317namp_
Content-Type: application/octet-stream;
	name="0001-x86-tdx-Fix-set_memory_decrypted-for-vmalloc-buffers.patch"
Content-Description:
 0001-x86-tdx-Fix-set_memory_decrypted-for-vmalloc-buffers.patch
Content-Disposition: attachment;
	filename="0001-x86-tdx-Fix-set_memory_decrypted-for-vmalloc-buffers.patch";
	size=3592; creation-date="Mon, 08 Jul 2024 21:42:15 GMT";
	modification-date="Mon, 08 Jul 2024 21:45:23 GMT"
Content-Transfer-Encoding: base64
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--_002_SA1PR21MB1317816DFCE6EF38A92CF254BFDA2SA1PR21MB1317namp_--