* [PATCH v2] KVM: x86: Fix stalled descriptor table accesses to MMIO
@ 2026-11-19 5:57 weichenchen
2026-11-19 6:21 ` sashiko-bot
0 siblings, 1 reply; 2+ messages in thread
From: weichenchen @ 2026-11-19 5:57 UTC (permalink / raw)
To: kvm, seanjc, pbonzini
Cc: weichenchen, x86, linux-kernel, gleb, srutherford, avi
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, then read the whole descriptor
in one emulated access. On a single page, this lets KVM use the
faulting GPA for both fields without translating the base field after
userspace has handled part of the read. For a split operand, translate
both pages before exiting to userspace. Use the emulator's read cache
to resume after MMIO and 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>
---
Changes in v2:
- Read the whole LGDT/LIDT operand in one read_emulated() call after
validating both fields. This avoids a second GVA translation after
userspace has handled the first part of a same-page read, as pointed
out by Sashiko.
- v1: https://lore.kernel.org/kvm/20261119032912.94364-1-weichen.chen@linux.alibaba.com/
On Intel VMX/EPT, the 64-bit LIDT and SIDT probes reached the following
HLT with the expected data for RAM and MMIO operands. For same-page
MMIO, both transferred eight bytes followed by two. A TDP-style mock
with a saved GPA counted one GPA lookup and zero software translations
through completion for both loads at all three operand sizes.
Six KVM selftests passed, including a split RAM/MMIO LIDT and a segment
limit fault before any userspace MMIO exit. 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 | 49 +++++++++++++++++++-----------------------
1 file changed, 22 insertions(+), 27 deletions(-)
diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
index c1b2128218..3a9a67f4b0 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,27 @@ 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;
+
+ rc = read_emulated(ctxt, limit_addr, &desc_ptr, desc_bytes);
if (rc != X86EMUL_CONTINUE)
return rc;
if (ctxt->mode == X86EMUL_MODE_PROT64 &&
@@ -4074,8 +4069,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 v2] KVM: x86: Fix stalled descriptor table accesses to MMIO
2026-11-19 5:57 [PATCH v2] KVM: x86: Fix stalled descriptor table accesses to MMIO weichenchen
@ 2026-11-19 6:21 ` sashiko-bot
0 siblings, 0 replies; 2+ messages in thread
From: sashiko-bot @ 2026-11-19 6:21 UTC (permalink / raw)
To: weichenchen, kvm
Thank you for your contribution! Sashiko AI review found 1 potential
issue to consider:
- [Medium] KVM: x86: unmasked addr.ea increment in em_lgdt_lidt() breaks
32-bit wrap
--
commit 14df3ccaae0dc59c054ba57d9b0335ad6207effb
Author: weichenchen <weichen.chen@linux.alibaba.com>
KVM: x86: Fix stalled descriptor table accesses to MMIO
This commit switches LGDT, LIDT, SGDT, and SIDT operand accesses from
standard memory accessors to emulated memory accessors and common writeback
so MMIO operands do not stall emulation.
> diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
> index c1b21282187f3..3a9a67f4b0d7c 100644
> --- a/arch/x86/kvm/emulate.c
> +++ b/arch/x86/kvm/emulate.c
[ ... ]
> @@ -3465,14 +3447,27 @@ 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;
> +
> + rc = read_emulated(ctxt, limit_addr, &desc_ptr, desc_bytes);
[Severity: Medium]
Does incrementing addr.ea without 32-bit masking break 32-bit address
wraparound for LGDT/LIDT at the top of a 4GB segment?
Because addr.ea is a 64-bit unsigned long, an operand at 0xfffffffe or
0xffffffff in 16-bit or 32-bit mode overflows addr.ea to 0x100000000 or
0x100000001, causing the second linearize() call to fail the addr.ea > lim
check and inject a spurious #GP(0) or #SS(0) when lim == 0xffffffff.
A single linearize(ctxt, addr, desc_bytes, false, &limit_addr) call (or
segmented_read(ctxt, ctxt->src.addr.mem, &desc_ptr, desc_bytes)) already
checks that the full descriptor fits within the segment limit when
lim != 0xffffffff while preserving 32-bit wraparound when lim == 0xffffffff,
and avoids the unused base_addr variable.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261119055747.23819-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 6:21 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-19 5:57 [PATCH v2] KVM: x86: Fix stalled descriptor table accesses to MMIO weichenchen
2026-11-19 6:21 ` sashiko-bot
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox