* [PATCH] KVM: x86: Fix stalled descriptor table accesses to MMIO
@ 2026-11-19 3:29 weichenchen
2026-11-19 3:56 ` sashiko-bot
0 siblings, 1 reply; 2+ messages in thread
From: weichenchen @ 2026-11-19 3:29 UTC (permalink / raw)
To: kvm, seanjc, pbonzini
Cc: x86, linux-kernel, gleb, srutherford, avi, weichenchen
Use the emulated memory accessors for the explicit operands of LGDT,
LIDT, SGDT and SIDT. When the operand has no backing memslot, the
standard accessors return X86EMUL_IO_NEEDED without queuing an MMIO
fragment. LIDT can repeat the generic operand read at the same RIP,
and SIDT can re-enter emulation without sending a write to userspace.
Check the segment bounds of both fields before reading the limit or
base. If the operand crosses a page boundary, pass the whole operand
to the emulated read so a fault on the second page is reported before
an MMIO exit to userspace. Keep the separate limit and base reads on
a single page. Use the emulator's read cache to resume after MMIO and
set NoAccess to skip the redundant generic source read.
Use the destination operand for common writeback of SGDT and SIDT. This
keeps the entire descriptor available until userspace completes a
ten-byte MMIO write.
Fixes: c3cd7ffaf57a ("KVM: x86 emulator: x86_emulate_insn() return -1 only in case of emulation failure")
Fixes: 129a72a0d3c8 ("KVM: x86: Introduce segmented_write_std")
Signed-off-by: weichenchen <weichen.chen@linux.alibaba.com>
---
On Intel VMX/EPT, LIDT and SIDT both reached the following HLT with the
expected IDTR data for RAM and MMIO operands. LIDT completed a 2-byte
and an 8-byte MMIO read. SIDT completed an 8-byte and a 2-byte write.
With only the limit field in range in 32-bit compatibility mode, LIDT
delivered #GP(0) at the expected RIP before any userspace MMIO exit.
The same selftest passed with forced emulation. A local extension to
set_memory_region_test also covered all four descriptor-table
instructions and a split RAM/MMIO LIDT.
A standalone test of the emulator and its MMIO fragment handling used
mock page translation to check a userspace MMIO page followed by a
non-present page. All 36 cross-page load cases returned a page fault
without preparing a userspace MMIO exit or updating GDTR or IDTR.
Six KVM selftests passed. Eight kvm-unit-tests suites at a2891d9528ef
reported 445 passes, five skips and no failures. Both vendor modules
built with KVM_WERROR. Runtime testing used Intel.
Codex assisted with the emulator changes and regression testing.
arch/x86/kvm/emulate.c | 57 ++++++++++++++++++++++--------------------
1 file changed, 30 insertions(+), 27 deletions(-)
diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
index c1b2128218..3bd720d983 100644
--- a/arch/x86/kvm/emulate.c
+++ b/arch/x86/kvm/emulate.c
@@ -918,23 +918,6 @@ static void *decode_register(struct x86_emulate_ctxt *ctxt, u8 modrm_reg,
return p;
}
-static int read_descriptor(struct x86_emulate_ctxt *ctxt,
- struct segmented_address addr,
- u16 *size, unsigned long *address, int op_bytes)
-{
- int rc;
-
- if (op_bytes == 2)
- op_bytes = 3;
- *address = 0;
- rc = segmented_read_std(ctxt, addr, size, 2);
- if (rc != X86EMUL_CONTINUE)
- return rc;
- addr.ea += 2;
- rc = segmented_read_std(ctxt, addr, address, op_bytes);
- return rc;
-}
-
EM_ASM_2(add);
EM_ASM_2(or);
EM_ASM_2(adc);
@@ -3447,10 +3430,9 @@ static int emulate_store_desc_ptr(struct x86_emulate_ctxt *ctxt,
ctxt->op_bytes = 4;
desc_ptr.address &= 0x00ffffff;
}
- /* Disable writeback. */
- ctxt->dst.type = OP_NONE;
- return segmented_write_std(ctxt, ctxt->dst.addr.mem,
- &desc_ptr, 2 + ctxt->op_bytes);
+ ctxt->dst.bytes = 2 + ctxt->op_bytes;
+ memcpy(ctxt->dst.valptr, &desc_ptr, ctxt->dst.bytes);
+ return X86EMUL_CONTINUE;
}
static int em_sgdt(struct x86_emulate_ctxt *ctxt)
@@ -3465,14 +3447,35 @@ static int em_sidt(struct x86_emulate_ctxt *ctxt)
static int em_lgdt_lidt(struct x86_emulate_ctxt *ctxt, bool lgdt)
{
- struct desc_ptr desc_ptr;
+ struct segmented_address addr = ctxt->src.addr.mem;
+ struct desc_ptr desc_ptr = {};
+ unsigned long limit_addr, base_addr;
+ unsigned int base_bytes, desc_bytes;
int rc;
if (ctxt->mode == X86EMUL_MODE_PROT64)
ctxt->op_bytes = 8;
- rc = read_descriptor(ctxt, ctxt->src.addr.mem,
- &desc_ptr.size, &desc_ptr.address,
- ctxt->op_bytes);
+ base_bytes = ctxt->op_bytes == 2 ? 3 : ctxt->op_bytes;
+ desc_bytes = sizeof(desc_ptr.size) + base_bytes;
+
+ /* Check both fields before an MMIO read can have side effects. */
+ rc = linearize(ctxt, addr, sizeof(desc_ptr.size), false, &limit_addr);
+ if (rc != X86EMUL_CONTINUE)
+ return rc;
+ addr.ea += sizeof(desc_ptr.size);
+ rc = linearize(ctxt, addr, base_bytes, false, &base_addr);
+ if (rc != X86EMUL_CONTINUE)
+ return rc;
+
+ /* Defer userspace MMIO until both pages have been translated. */
+ if (offset_in_page(limit_addr) + desc_bytes > PAGE_SIZE) {
+ rc = read_emulated(ctxt, limit_addr, &desc_ptr, desc_bytes);
+ } else {
+ rc = read_emulated(ctxt, limit_addr, &desc_ptr.size, sizeof(desc_ptr.size));
+ if (rc != X86EMUL_CONTINUE)
+ return rc;
+ rc = read_emulated(ctxt, base_addr, &desc_ptr.address, base_bytes);
+ }
if (rc != X86EMUL_CONTINUE)
return rc;
if (ctxt->mode == X86EMUL_MODE_PROT64 &&
@@ -4074,8 +4077,8 @@ static const struct opcode group6[] = {
static const struct group_dual group7 = { {
II(Mov | DstMem, em_sgdt, sgdt),
II(Mov | DstMem, em_sidt, sidt),
- II(SrcMem | Priv, em_lgdt, lgdt),
- II(SrcMem | Priv, em_lidt, lidt),
+ II(SrcMem | Priv | NoAccess, em_lgdt, lgdt),
+ II(SrcMem | Priv | NoAccess, em_lidt, lidt),
II(SrcNone | DstMem | Mov, em_smsw, smsw), N,
II(SrcMem16 | Mov | Priv, em_lmsw, lmsw),
II(SrcMem | ByteOp | Priv | NoAccess, em_invlpg, invlpg),
base-commit: cbe54fc3462b3949ab27b9ae81fb9ddb509040c7
--
2.53.0
^ permalink raw reply related [flat|nested] 2+ messages in thread* Re: [PATCH] KVM: x86: Fix stalled descriptor table accesses to MMIO
2026-11-19 3:29 [PATCH] KVM: x86: Fix stalled descriptor table accesses to MMIO weichenchen
@ 2026-11-19 3:56 ` sashiko-bot
0 siblings, 0 replies; 2+ messages in thread
From: sashiko-bot @ 2026-11-19 3:56 UTC (permalink / raw)
To: weichenchen, kvm
Thank you for your contribution! Sashiko AI review found 1 potential
issue to consider:
- [Medium] KVM: x86: split single-page reads in em_lgdt_lidt() miss
saved GPA
--
commit db71a6d851801384a40299e7d8acce741f81c256
Author: weichenchen <weichen.chen@linux.alibaba.com>
KVM: x86: Fix stalled descriptor table accesses to MMIO
This commit switches LGDT, LIDT, SGDT and SIDT from standard guest memory
accessors to emulated memory accessors so that descriptor table accesses
targeting MMIO queue MMIO fragments and complete properly across userspace
exits.
> diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
> index c1b21282187f3..3bd720d983f8e 100644
> --- a/arch/x86/kvm/emulate.c
> +++ b/arch/x86/kvm/emulate.c
[ ... ]
> @@ -3465,14 +3447,35 @@ static int em_sidt(struct x86_emulate_ctxt *ctxt)
>
> static int em_lgdt_lidt(struct x86_emulate_ctxt *ctxt, bool lgdt)
> {
> - struct desc_ptr desc_ptr;
> + struct segmented_address addr = ctxt->src.addr.mem;
> + struct desc_ptr desc_ptr = {};
> + unsigned long limit_addr, base_addr;
> + unsigned int base_bytes, desc_bytes;
> int rc;
>
> if (ctxt->mode == X86EMUL_MODE_PROT64)
> ctxt->op_bytes = 8;
> - rc = read_descriptor(ctxt, ctxt->src.addr.mem,
> - &desc_ptr.size, &desc_ptr.address,
> - ctxt->op_bytes);
> + base_bytes = ctxt->op_bytes == 2 ? 3 : ctxt->op_bytes;
> + desc_bytes = sizeof(desc_ptr.size) + base_bytes;
> +
> + /* Check both fields before an MMIO read can have side effects. */
> + rc = linearize(ctxt, addr, sizeof(desc_ptr.size), false, &limit_addr);
> + if (rc != X86EMUL_CONTINUE)
> + return rc;
> + addr.ea += sizeof(desc_ptr.size);
> + rc = linearize(ctxt, addr, base_bytes, false, &base_addr);
> + if (rc != X86EMUL_CONTINUE)
> + return rc;
> +
> + /* Defer userspace MMIO until both pages have been translated. */
> + if (offset_in_page(limit_addr) + desc_bytes > PAGE_SIZE) {
> + rc = read_emulated(ctxt, limit_addr, &desc_ptr, desc_bytes);
> + } else {
> + rc = read_emulated(ctxt, limit_addr, &desc_ptr.size, sizeof(desc_ptr.size));
> + if (rc != X86EMUL_CONTINUE)
> + return rc;
> + rc = read_emulated(ctxt, base_addr, &desc_ptr.address, base_bytes);
> + }
[Severity: Medium]
Why split the single-page case into two read_emulated() calls instead of
always issuing a single read_emulated(ctxt, limit_addr, &desc_ptr,
desc_bytes)?
On a single-page MMIO operand, the first read at limit_addr matches the
hardware-saved GPA in emulator_read_write_onepage(), but the second read on
resume passes base_addr (limit_addr + 2), which misses the page-offset
check:
arch/x86/kvm/x86.c:emulator_read_write_onepage() {
...
if ((ctxt->gpa_access & (write ? ACC_WRITE_MASK : ACC_READ_MASK)) &&
emulator_can_use_gpa(ctxt) &&
(addr & ~PAGE_MASK) == (ctxt->gpa_val & ~PAGE_MASK)) {
gpa = ctxt->gpa_val;
ret = vcpu_is_mmio_gpa(vcpu, addr, gpa, write);
} else {
ret = vcpu_mmio_gva_to_gpa(vcpu, addr, &gpa, exception, write);
...
}
Because vcpu->arch.mmio_gva is 0 when TDP is enabled,
vcpu_mmio_gva_to_gpa() falls back to walking the guest page tables in
software after the first 2-byte MMIO read has already exited to userspace.
On SEV guests with encrypted guest page tables, that software walk reads
ciphertext as PTEs and injects a spurious #PF or translates a bogus GPA; on
SMP guests, a concurrent PTE update between the two MMIO exits can fault mid-
instruction after the first MMIO read has already taken effect.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261119032912.94364-1-weichen.chen@linux.alibaba.com?part=1
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2026-11-19 3:56 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-19 3:29 [PATCH] KVM: x86: Fix stalled descriptor table accesses to MMIO weichenchen
2026-11-19 3:56 ` sashiko-bot
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox