[pve-kernel.git] / patches / kernel / 0012-KVM-x86-emulator-smm-use-smram-struct-for-64-bit-smr.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Maxim Levitsky <mlevitsk@redhat.com>
Date: Wed, 3 Aug 2022 18:50:08 +0300
Subject: [PATCH] KVM: x86: emulator/smm: use smram struct for 64 bit smram
 load/restore
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Use kvm_smram_state_64 struct to save/restore the 64 bit SMM state
(used when X86_FEATURE_LM is present in the guest CPUID,
regardless of 32-bitness of the guest).

Signed-off-by: Maxim Levitsky <mlevitsk@redhat.com>
Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
---
 arch/x86/kvm/emulate.c | 88 ++++++++++++++----------------------------
 arch/x86/kvm/x86.c     | 75 ++++++++++++++++-------------------
 2 files changed, 62 insertions(+), 101 deletions(-)

diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
index 65d82292ccec..03f9e5aa036e 100644
--- a/arch/x86/kvm/emulate.c
+++ b/arch/x86/kvm/emulate.c
@@ -2373,24 +2373,16 @@ static void rsm_load_seg_32(struct x86_emulate_ctxt *ctxt,
 }
 
 #ifdef CONFIG_X86_64
-static int rsm_load_seg_64(struct x86_emulate_ctxt *ctxt, const char *smstate,
-			   int n)
+static void rsm_load_seg_64(struct x86_emulate_ctxt *ctxt,
+			    const struct kvm_smm_seg_state_64 *state,
+			    int n)
 {
 	struct desc_struct desc;
-	int offset;
-	u16 selector;
-	u32 base3;
-
-	offset = 0x7e00 + n * 16;
-
-	selector =                GET_SMSTATE(u16, smstate, offset);
-	rsm_set_desc_flags(&desc, GET_SMSTATE(u16, smstate, offset + 2) << 8);
-	set_desc_limit(&desc,     GET_SMSTATE(u32, smstate, offset + 4));
-	set_desc_base(&desc,      GET_SMSTATE(u32, smstate, offset + 8));
-	base3 =                   GET_SMSTATE(u32, smstate, offset + 12);
 
-	ctxt->ops->set_segment(ctxt, selector, &desc, base3, n);
-	return X86EMUL_CONTINUE;
+	rsm_set_desc_flags(&desc, state->attributes << 8);
+	set_desc_limit(&desc,     state->limit);
+	set_desc_base(&desc,      (u32)state->base);
+	ctxt->ops->set_segment(ctxt, state->selector, &desc, state->base >> 32, n);
 }
 #endif
 
@@ -2484,71 +2476,49 @@ static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt,
 
 #ifdef CONFIG_X86_64
 static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt,
-			     const char *smstate)
+			     const struct kvm_smram_state_64 *smstate)
 {
-	struct desc_struct desc;
 	struct desc_ptr dt;
-	u64 val, cr0, cr3, cr4;
-	u32 base3;
-	u16 selector;
 	int i, r;
 
 	for (i = 0; i < 16; i++)
-		*reg_write(ctxt, i) = GET_SMSTATE(u64, smstate, 0x7ff8 - i * 8);
+		*reg_write(ctxt, i) = smstate->gprs[15 - i];
 
-	ctxt->_eip   = GET_SMSTATE(u64, smstate, 0x7f78);
-	ctxt->eflags = GET_SMSTATE(u32, smstate, 0x7f70) | X86_EFLAGS_FIXED;
+	ctxt->_eip   = smstate->rip;
+	ctxt->eflags = smstate->rflags | X86_EFLAGS_FIXED;
 
-	val = GET_SMSTATE(u64, smstate, 0x7f68);
-
-	if (ctxt->ops->set_dr(ctxt, 6, val))
+	if (ctxt->ops->set_dr(ctxt, 6, smstate->dr6))
 		return X86EMUL_UNHANDLEABLE;
-
-	val = GET_SMSTATE(u64, smstate, 0x7f60);
-
-	if (ctxt->ops->set_dr(ctxt, 7, val))
+	if (ctxt->ops->set_dr(ctxt, 7, smstate->dr7))
 		return X86EMUL_UNHANDLEABLE;
 
-	cr0 =                       GET_SMSTATE(u64, smstate, 0x7f58);
-	cr3 =                       GET_SMSTATE(u64, smstate, 0x7f50);
-	cr4 =                       GET_SMSTATE(u64, smstate, 0x7f48);
-	ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smstate, 0x7f00));
-	val =                       GET_SMSTATE(u64, smstate, 0x7ed0);
+	ctxt->ops->set_smbase(ctxt, smstate->smbase);
 
-	if (ctxt->ops->set_msr(ctxt, MSR_EFER, val & ~EFER_LMA))
+	if (ctxt->ops->set_msr(ctxt, MSR_EFER, smstate->efer & ~EFER_LMA))
 		return X86EMUL_UNHANDLEABLE;
 
-	selector =                  GET_SMSTATE(u32, smstate, 0x7e90);
-	rsm_set_desc_flags(&desc,   GET_SMSTATE(u32, smstate, 0x7e92) << 8);
-	set_desc_limit(&desc,       GET_SMSTATE(u32, smstate, 0x7e94));
-	set_desc_base(&desc,        GET_SMSTATE(u32, smstate, 0x7e98));
-	base3 =                     GET_SMSTATE(u32, smstate, 0x7e9c);
-	ctxt->ops->set_segment(ctxt, selector, &desc, base3, VCPU_SREG_TR);
+	rsm_load_seg_64(ctxt, &smstate->tr, VCPU_SREG_TR);
 
-	dt.size =                   GET_SMSTATE(u32, smstate, 0x7e84);
-	dt.address =                GET_SMSTATE(u64, smstate, 0x7e88);
+	dt.size =                   smstate->idtr.limit;
+	dt.address =                smstate->idtr.base;
 	ctxt->ops->set_idt(ctxt, &dt);
 
-	selector =                  GET_SMSTATE(u32, smstate, 0x7e70);
-	rsm_set_desc_flags(&desc,   GET_SMSTATE(u32, smstate, 0x7e72) << 8);
-	set_desc_limit(&desc,       GET_SMSTATE(u32, smstate, 0x7e74));
-	set_desc_base(&desc,        GET_SMSTATE(u32, smstate, 0x7e78));
-	base3 =                     GET_SMSTATE(u32, smstate, 0x7e7c);
-	ctxt->ops->set_segment(ctxt, selector, &desc, base3, VCPU_SREG_LDTR);
+	rsm_load_seg_64(ctxt, &smstate->ldtr, VCPU_SREG_LDTR);
 
-	dt.size =                   GET_SMSTATE(u32, smstate, 0x7e64);
-	dt.address =                GET_SMSTATE(u64, smstate, 0x7e68);
+	dt.size =                   smstate->gdtr.limit;
+	dt.address =                smstate->gdtr.base;
 	ctxt->ops->set_gdt(ctxt, &dt);
 
-	r = rsm_enter_protected_mode(ctxt, cr0, cr3, cr4);
+	r = rsm_enter_protected_mode(ctxt, smstate->cr0, smstate->cr3, smstate->cr4);
 	if (r != X86EMUL_CONTINUE)
 		return r;
 
-	for (i = 0; i < 6; i++) {
-		r = rsm_load_seg_64(ctxt, smstate, i);
-		if (r != X86EMUL_CONTINUE)
-			return r;
-	}
+	rsm_load_seg_64(ctxt, &smstate->es, VCPU_SREG_ES);
+	rsm_load_seg_64(ctxt, &smstate->cs, VCPU_SREG_CS);
+	rsm_load_seg_64(ctxt, &smstate->ss, VCPU_SREG_SS);
+	rsm_load_seg_64(ctxt, &smstate->ds, VCPU_SREG_DS);
+	rsm_load_seg_64(ctxt, &smstate->fs, VCPU_SREG_FS);
+	rsm_load_seg_64(ctxt, &smstate->gs, VCPU_SREG_GS);
 
 	return X86EMUL_CONTINUE;
 }
@@ -2623,7 +2593,7 @@ static int em_rsm(struct x86_emulate_ctxt *ctxt)
 
 #ifdef CONFIG_X86_64
 	if (emulator_has_longmode(ctxt))
-		ret = rsm_load_state_64(ctxt, (const char *)&smram);
+		ret = rsm_load_state_64(ctxt, &smram.smram64);
 	else
 #endif
 		ret = rsm_load_state_32(ctxt, &smram.smram32);
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 48a15a71c543..f5d3c0ff083d 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -10136,20 +10136,17 @@ static void enter_smm_save_seg_32(struct kvm_vcpu *vcpu,
 }
 
 #ifdef CONFIG_X86_64
-static void enter_smm_save_seg_64(struct kvm_vcpu *vcpu, char *buf, int n)
+static void enter_smm_save_seg_64(struct kvm_vcpu *vcpu,
+				  struct kvm_smm_seg_state_64 *state,
+				  int n)
 {
 	struct kvm_segment seg;
-	int offset;
-	u16 flags;
 
 	kvm_get_segment(vcpu, &seg, n);
-	offset = 0x7e00 + n * 16;
-
-	flags = enter_smm_get_segment_flags(&seg) >> 8;
-	put_smstate(u16, buf, offset, seg.selector);
-	put_smstate(u16, buf, offset + 2, flags);
-	put_smstate(u32, buf, offset + 4, seg.limit);
-	put_smstate(u64, buf, offset + 8, seg.base);
+	state->selector = seg.selector;
+	state->attributes = enter_smm_get_segment_flags(&seg) >> 8;
+	state->limit = seg.limit;
+	state->base = seg.base;
 }
 #endif
 
@@ -10197,57 +10194,51 @@ static void enter_smm_save_state_32(struct kvm_vcpu *vcpu, struct kvm_smram_stat
 }
 
 #ifdef CONFIG_X86_64
-static void enter_smm_save_state_64(struct kvm_vcpu *vcpu, char *buf)
+static void enter_smm_save_state_64(struct kvm_vcpu *vcpu, struct kvm_smram_state_64 *smram)
 {
 	struct desc_ptr dt;
-	struct kvm_segment seg;
 	unsigned long val;
 	int i;
 
 	for (i = 0; i < 16; i++)
-		put_smstate(u64, buf, 0x7ff8 - i * 8, kvm_register_read_raw(vcpu, i));
+		smram->gprs[15 - i] = kvm_register_read_raw(vcpu, i);
+
+	smram->rip    = kvm_rip_read(vcpu);
+	smram->rflags = kvm_get_rflags(vcpu);
 
-	put_smstate(u64, buf, 0x7f78, kvm_rip_read(vcpu));
-	put_smstate(u32, buf, 0x7f70, kvm_get_rflags(vcpu));
 
 	kvm_get_dr(vcpu, 6, &val);
-	put_smstate(u64, buf, 0x7f68, val);
+	smram->dr6 = val;
 	kvm_get_dr(vcpu, 7, &val);
-	put_smstate(u64, buf, 0x7f60, val);
-
-	put_smstate(u64, buf, 0x7f58, kvm_read_cr0(vcpu));
-	put_smstate(u64, buf, 0x7f50, kvm_read_cr3(vcpu));
-	put_smstate(u64, buf, 0x7f48, kvm_read_cr4(vcpu));
+	smram->dr7 = val;
 
-	put_smstate(u32, buf, 0x7f00, vcpu->arch.smbase);
+	smram->cr0 = kvm_read_cr0(vcpu);
+	smram->cr3 = kvm_read_cr3(vcpu);
+	smram->cr4 = kvm_read_cr4(vcpu);
 
-	/* revision id */
-	put_smstate(u32, buf, 0x7efc, 0x00020064);
+	smram->smbase = vcpu->arch.smbase;
+	smram->smm_revison = 0x00020064;
 
-	put_smstate(u64, buf, 0x7ed0, vcpu->arch.efer);
+	smram->efer = vcpu->arch.efer;
 
-	kvm_get_segment(vcpu, &seg, VCPU_SREG_TR);
-	put_smstate(u16, buf, 0x7e90, seg.selector);
-	put_smstate(u16, buf, 0x7e92, enter_smm_get_segment_flags(&seg) >> 8);
-	put_smstate(u32, buf, 0x7e94, seg.limit);
-	put_smstate(u64, buf, 0x7e98, seg.base);
+	enter_smm_save_seg_64(vcpu, &smram->tr, VCPU_SREG_TR);
 
 	static_call(kvm_x86_get_idt)(vcpu, &dt);
-	put_smstate(u32, buf, 0x7e84, dt.size);
-	put_smstate(u64, buf, 0x7e88, dt.address);
+	smram->idtr.limit = dt.size;
+	smram->idtr.base = dt.address;
 
-	kvm_get_segment(vcpu, &seg, VCPU_SREG_LDTR);
-	put_smstate(u16, buf, 0x7e70, seg.selector);
-	put_smstate(u16, buf, 0x7e72, enter_smm_get_segment_flags(&seg) >> 8);
-	put_smstate(u32, buf, 0x7e74, seg.limit);
-	put_smstate(u64, buf, 0x7e78, seg.base);
+	enter_smm_save_seg_64(vcpu, &smram->ldtr, VCPU_SREG_LDTR);
 
 	static_call(kvm_x86_get_gdt)(vcpu, &dt);
-	put_smstate(u32, buf, 0x7e64, dt.size);
-	put_smstate(u64, buf, 0x7e68, dt.address);
+	smram->gdtr.limit = dt.size;
+	smram->gdtr.base = dt.address;
 
-	for (i = 0; i < 6; i++)
-		enter_smm_save_seg_64(vcpu, buf, i);
+	enter_smm_save_seg_64(vcpu, &smram->es, VCPU_SREG_ES);
+	enter_smm_save_seg_64(vcpu, &smram->cs, VCPU_SREG_CS);
+	enter_smm_save_seg_64(vcpu, &smram->ss, VCPU_SREG_SS);
+	enter_smm_save_seg_64(vcpu, &smram->ds, VCPU_SREG_DS);
+	enter_smm_save_seg_64(vcpu, &smram->fs, VCPU_SREG_FS);
+	enter_smm_save_seg_64(vcpu, &smram->gs, VCPU_SREG_GS);
 }
 #endif
 
@@ -10261,7 +10252,7 @@ static void enter_smm(struct kvm_vcpu *vcpu)
 	memset(smram.bytes, 0, sizeof(smram.bytes));
 #ifdef CONFIG_X86_64
 	if (guest_cpuid_has(vcpu, X86_FEATURE_LM))
-		enter_smm_save_state_64(vcpu, (char *)&smram);
+		enter_smm_save_state_64(vcpu, &smram.smram64);
 	else
 #endif
 		enter_smm_save_state_32(vcpu, &smram.smram32);
Commit	Line	Data
54ebe3cb TL	1	From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
54ebe3cb TL	2	From: Maxim Levitsky <mlevitsk@redhat.com>
4fc427d9	3	Date: Wed, 3 Aug 2022 18:50:08 +0300
54ebe3cb TL	4	Subject: [PATCH] KVM: x86: emulator/smm: use smram struct for 64 bit smram
54ebe3cb TL	5	load/restore
826eb0ff FG	6	MIME-Version: 1.0
	7	Content-Type: text/plain; charset=UTF-8
	8	Content-Transfer-Encoding: 8bit
54ebe3cb TL	9
	10	Use kvm_smram_state_64 struct to save/restore the 64 bit SMM state
	11	(used when X86_FEATURE_LM is present in the guest CPUID,
	12	regardless of 32-bitness of the guest).
	13
	14	Signed-off-by: Maxim Levitsky <mlevitsk@redhat.com>
	15	Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
826eb0ff	16	Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
54ebe3cb TL	17	---
	18	arch/x86/kvm/emulate.c \| 88 ++++++++++++++----------------------------
	19	arch/x86/kvm/x86.c \| 75 ++++++++++++++++-------------------
	20	2 files changed, 62 insertions(+), 101 deletions(-)
	21
	22	diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
12247ad0	23	index 65d82292ccec..03f9e5aa036e 100644
54ebe3cb TL	24	--- a/arch/x86/kvm/emulate.c
54ebe3cb TL	25	+++ b/arch/x86/kvm/emulate.c
4fc427d9	26	@@ -2373,24 +2373,16 @@ static void rsm_load_seg_32(struct x86_emulate_ctxt *ctxt,
54ebe3cb TL	27	}
	28
	29	#ifdef CONFIG_X86_64
	30	-static int rsm_load_seg_64(struct x86_emulate_ctxt ctxt, const char smstate,
	31	- int n)
	32	+static void rsm_load_seg_64(struct x86_emulate_ctxt *ctxt,
4fc427d9	33	+ const struct kvm_smm_seg_state_64 *state,
54ebe3cb TL	34	+ int n)
	35	{
	36	struct desc_struct desc;
	37	- int offset;
	38	- u16 selector;
	39	- u32 base3;
	40	-
	41	- offset = 0x7e00 + n * 16;
	42	-
	43	- selector = GET_SMSTATE(u16, smstate, offset);
	44	- rsm_set_desc_flags(&desc, GET_SMSTATE(u16, smstate, offset + 2) << 8);
	45	- set_desc_limit(&desc, GET_SMSTATE(u32, smstate, offset + 4));
	46	- set_desc_base(&desc, GET_SMSTATE(u32, smstate, offset + 8));
	47	- base3 = GET_SMSTATE(u32, smstate, offset + 12);
	48
	49	- ctxt->ops->set_segment(ctxt, selector, &desc, base3, n);
	50	- return X86EMUL_CONTINUE;
	51	+ rsm_set_desc_flags(&desc, state->attributes << 8);
	52	+ set_desc_limit(&desc, state->limit);
	53	+ set_desc_base(&desc, (u32)state->base);
	54	+ ctxt->ops->set_segment(ctxt, state->selector, &desc, state->base >> 32, n);
	55	}
	56	#endif
	57
4fc427d9	58	@@ -2484,71 +2476,49 @@ static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt,
54ebe3cb TL	59
	60	#ifdef CONFIG_X86_64
	61	static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt,
	62	- const char *smstate)
4fc427d9	63	+ const struct kvm_smram_state_64 *smstate)
54ebe3cb TL	64	{
	65	- struct desc_struct desc;
	66	struct desc_ptr dt;
	67	- u64 val, cr0, cr3, cr4;
	68	- u32 base3;
	69	- u16 selector;
	70	int i, r;
	71
	72	for (i = 0; i < 16; i++)
	73	- reg_write(ctxt, i) = GET_SMSTATE(u64, smstate, 0x7ff8 - i 8);
	74	+ *reg_write(ctxt, i) = smstate->gprs[15 - i];
	75
	76	- ctxt->_eip = GET_SMSTATE(u64, smstate, 0x7f78);
	77	- ctxt->eflags = GET_SMSTATE(u32, smstate, 0x7f70) \| X86_EFLAGS_FIXED;
	78	+ ctxt->_eip = smstate->rip;
	79	+ ctxt->eflags = smstate->rflags \| X86_EFLAGS_FIXED;
	80
	81	- val = GET_SMSTATE(u64, smstate, 0x7f68);
	82	-
	83	- if (ctxt->ops->set_dr(ctxt, 6, val))
	84	+ if (ctxt->ops->set_dr(ctxt, 6, smstate->dr6))
	85	return X86EMUL_UNHANDLEABLE;
	86	-
	87	- val = GET_SMSTATE(u64, smstate, 0x7f60);
	88	-
	89	- if (ctxt->ops->set_dr(ctxt, 7, val))
	90	+ if (ctxt->ops->set_dr(ctxt, 7, smstate->dr7))
	91	return X86EMUL_UNHANDLEABLE;
	92
	93	- cr0 = GET_SMSTATE(u64, smstate, 0x7f58);
	94	- cr3 = GET_SMSTATE(u64, smstate, 0x7f50);
	95	- cr4 = GET_SMSTATE(u64, smstate, 0x7f48);
	96	- ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smstate, 0x7f00));
	97	- val = GET_SMSTATE(u64, smstate, 0x7ed0);
	98	+ ctxt->ops->set_smbase(ctxt, smstate->smbase);
	99
	100	- if (ctxt->ops->set_msr(ctxt, MSR_EFER, val & ~EFER_LMA))
	101	+ if (ctxt->ops->set_msr(ctxt, MSR_EFER, smstate->efer & ~EFER_LMA))
	102	return X86EMUL_UNHANDLEABLE;
	103
	104	- selector = GET_SMSTATE(u32, smstate, 0x7e90);
	105	- rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7e92) << 8);
	106	- set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7e94));
	107	- set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7e98));
	108	- base3 = GET_SMSTATE(u32, smstate, 0x7e9c);
	109	- ctxt->ops->set_segment(ctxt, selector, &desc, base3, VCPU_SREG_TR);
	110	+ rsm_load_seg_64(ctxt, &smstate->tr, VCPU_SREG_TR);
	111
	112	- dt.size = GET_SMSTATE(u32, smstate, 0x7e84);
	113	- dt.address = GET_SMSTATE(u64, smstate, 0x7e88);
	114	+ dt.size = smstate->idtr.limit;
	115	+ dt.address = smstate->idtr.base;
	116	ctxt->ops->set_idt(ctxt, &dt);
	117
	118	- selector = GET_SMSTATE(u32, smstate, 0x7e70);
	119	- rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7e72) << 8);
	120	- set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7e74));
	121	- set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7e78));
	122	- base3 = GET_SMSTATE(u32, smstate, 0x7e7c);
	123	- ctxt->ops->set_segment(ctxt, selector, &desc, base3, VCPU_SREG_LDTR);
	124	+ rsm_load_seg_64(ctxt, &smstate->ldtr, VCPU_SREG_LDTR);
	125
	126	- dt.size = GET_SMSTATE(u32, smstate, 0x7e64);
	127	- dt.address = GET_SMSTATE(u64, smstate, 0x7e68);
128	+ dt.size = smstate->gdtr.limit;
129	+ dt.address = smstate->gdtr.base;
130	ctxt->ops->set_gdt(ctxt, &dt);
131
132	- r = rsm_enter_protected_mode(ctxt, cr0, cr3, cr4);
133	+ r = rsm_enter_protected_mode(ctxt, smstate->cr0, smstate->cr3, smstate->cr4);
134	if (r != X86EMUL_CONTINUE)
135	return r;
136
137	- for (i = 0; i < 6; i++) {
138	- r = rsm_load_seg_64(ctxt, smstate, i);
139	- if (r != X86EMUL_CONTINUE)
140	- return r;
141	- }
142	+ rsm_load_seg_64(ctxt, &smstate->es, VCPU_SREG_ES);
143	+ rsm_load_seg_64(ctxt, &smstate->cs, VCPU_SREG_CS);
144	+ rsm_load_seg_64(ctxt, &smstate->ss, VCPU_SREG_SS);
145	+ rsm_load_seg_64(ctxt, &smstate->ds, VCPU_SREG_DS);
146	+ rsm_load_seg_64(ctxt, &smstate->fs, VCPU_SREG_FS);
147	+ rsm_load_seg_64(ctxt, &smstate->gs, VCPU_SREG_GS);
148
149	return X86EMUL_CONTINUE;
150	}
4fc427d9	151	@@ -2623,7 +2593,7 @@ static int em_rsm(struct x86_emulate_ctxt *ctxt)
54ebe3cb TL	152
	153	#ifdef CONFIG_X86_64
	154	if (emulator_has_longmode(ctxt))
4fc427d9 TL	155	- ret = rsm_load_state_64(ctxt, (const char *)&smram);
4fc427d9 TL	156	+ ret = rsm_load_state_64(ctxt, &smram.smram64);
54ebe3cb TL	157	else
54ebe3cb TL	158	#endif
4fc427d9	159	ret = rsm_load_state_32(ctxt, &smram.smram32);
54ebe3cb	160	diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
fc2b61b1	161	index 48a15a71c543..f5d3c0ff083d 100644
54ebe3cb TL	162	--- a/arch/x86/kvm/x86.c
54ebe3cb TL	163	+++ b/arch/x86/kvm/x86.c
fc2b61b1	164	@@ -10136,20 +10136,17 @@ static void enter_smm_save_seg_32(struct kvm_vcpu *vcpu,
54ebe3cb TL	165	}
	166
	167	#ifdef CONFIG_X86_64
	168	-static void enter_smm_save_seg_64(struct kvm_vcpu vcpu, char buf, int n)
	169	+static void enter_smm_save_seg_64(struct kvm_vcpu *vcpu,
	170	+ struct kvm_smm_seg_state_64 *state,
	171	+ int n)
	172	{
	173	struct kvm_segment seg;
	174	- int offset;
	175	- u16 flags;
	176
	177	kvm_get_segment(vcpu, &seg, n);
	178	- offset = 0x7e00 + n * 16;
	179	-
	180	- flags = enter_smm_get_segment_flags(&seg) >> 8;
	181	- put_smstate(u16, buf, offset, seg.selector);
	182	- put_smstate(u16, buf, offset + 2, flags);
	183	- put_smstate(u32, buf, offset + 4, seg.limit);
	184	- put_smstate(u64, buf, offset + 8, seg.base);
	185	+ state->selector = seg.selector;
	186	+ state->attributes = enter_smm_get_segment_flags(&seg) >> 8;
	187	+ state->limit = seg.limit;
	188	+ state->base = seg.base;
	189	}
	190	#endif
	191
fc2b61b1	192	@@ -10197,57 +10194,51 @@ static void enter_smm_save_state_32(struct kvm_vcpu *vcpu, struct kvm_smram_stat
54ebe3cb TL	193	}
	194
	195	#ifdef CONFIG_X86_64
	196	-static void enter_smm_save_state_64(struct kvm_vcpu vcpu, char buf)
	197	+static void enter_smm_save_state_64(struct kvm_vcpu vcpu, struct kvm_smram_state_64 smram)
	198	{
	199	struct desc_ptr dt;
	200	- struct kvm_segment seg;
	201	unsigned long val;
	202	int i;
	203
	204	for (i = 0; i < 16; i++)
	205	- put_smstate(u64, buf, 0x7ff8 - i * 8, kvm_register_read_raw(vcpu, i));
	206	+ smram->gprs[15 - i] = kvm_register_read_raw(vcpu, i);
	207	+
	208	+ smram->rip = kvm_rip_read(vcpu);
	209	+ smram->rflags = kvm_get_rflags(vcpu);
	210
	211	- put_smstate(u64, buf, 0x7f78, kvm_rip_read(vcpu));
	212	- put_smstate(u32, buf, 0x7f70, kvm_get_rflags(vcpu));
	213
	214	kvm_get_dr(vcpu, 6, &val);
	215	- put_smstate(u64, buf, 0x7f68, val);
	216	+ smram->dr6 = val;
	217	kvm_get_dr(vcpu, 7, &val);
	218	- put_smstate(u64, buf, 0x7f60, val);
	219	-
	220	- put_smstate(u64, buf, 0x7f58, kvm_read_cr0(vcpu));
	221	- put_smstate(u64, buf, 0x7f50, kvm_read_cr3(vcpu));
	222	- put_smstate(u64, buf, 0x7f48, kvm_read_cr4(vcpu));
	223	+ smram->dr7 = val;
	224
	225	- put_smstate(u32, buf, 0x7f00, vcpu->arch.smbase);
	226	+ smram->cr0 = kvm_read_cr0(vcpu);
	227	+ smram->cr3 = kvm_read_cr3(vcpu);
	228	+ smram->cr4 = kvm_read_cr4(vcpu);
	229
	230	- /* revision id */
	231	- put_smstate(u32, buf, 0x7efc, 0x00020064);
	232	+ smram->smbase = vcpu->arch.smbase;
	233	+ smram->smm_revison = 0x00020064;
	234
	235	- put_smstate(u64, buf, 0x7ed0, vcpu->arch.efer);
	236	+ smram->efer = vcpu->arch.efer;
	237
	238	- kvm_get_segment(vcpu, &seg, VCPU_SREG_TR);
	239	- put_smstate(u16, buf, 0x7e90, seg.selector);
	240	- put_smstate(u16, buf, 0x7e92, enter_smm_get_segment_flags(&seg) >> 8);
	241	- put_smstate(u32, buf, 0x7e94, seg.limit);
	242	- put_smstate(u64, buf, 0x7e98, seg.base);
	243	+ enter_smm_save_seg_64(vcpu, &smram->tr, VCPU_SREG_TR);
	244
	245	static_call(kvm_x86_get_idt)(vcpu, &dt);
	246	- put_smstate(u32, buf, 0x7e84, dt.size);
	247	- put_smstate(u64, buf, 0x7e88, dt.address);
	248	+ smram->idtr.limit = dt.size;
	249	+ smram->idtr.base = dt.address;
	250
	251	- kvm_get_segment(vcpu, &seg, VCPU_SREG_LDTR);
	252	- put_smstate(u16, buf, 0x7e70, seg.selector);
	253	- put_smstate(u16, buf, 0x7e72, enter_smm_get_segment_flags(&seg) >> 8);
	254	- put_smstate(u32, buf, 0x7e74, seg.limit);
	255	- put_smstate(u64, buf, 0x7e78, seg.base);
	256	+ enter_smm_save_seg_64(vcpu, &smram->ldtr, VCPU_SREG_LDTR);
257
258	static_call(kvm_x86_get_gdt)(vcpu, &dt);
259	- put_smstate(u32, buf, 0x7e64, dt.size);
260	- put_smstate(u64, buf, 0x7e68, dt.address);
261	+ smram->gdtr.limit = dt.size;
262	+ smram->gdtr.base = dt.address;
263
264	- for (i = 0; i < 6; i++)
265	- enter_smm_save_seg_64(vcpu, buf, i);
266	+ enter_smm_save_seg_64(vcpu, &smram->es, VCPU_SREG_ES);
267	+ enter_smm_save_seg_64(vcpu, &smram->cs, VCPU_SREG_CS);
268	+ enter_smm_save_seg_64(vcpu, &smram->ss, VCPU_SREG_SS);
269	+ enter_smm_save_seg_64(vcpu, &smram->ds, VCPU_SREG_DS);
270	+ enter_smm_save_seg_64(vcpu, &smram->fs, VCPU_SREG_FS);
271	+ enter_smm_save_seg_64(vcpu, &smram->gs, VCPU_SREG_GS);
272	}
273	#endif
274
fc2b61b1	275	@@ -10261,7 +10252,7 @@ static void enter_smm(struct kvm_vcpu *vcpu)
4fc427d9	276	memset(smram.bytes, 0, sizeof(smram.bytes));
54ebe3cb TL	277	#ifdef CONFIG_X86_64
54ebe3cb TL	278	if (guest_cpuid_has(vcpu, X86_FEATURE_LM))
4fc427d9 TL	279	- enter_smm_save_state_64(vcpu, (char *)&smram);
4fc427d9 TL	280	+ enter_smm_save_state_64(vcpu, &smram.smram64);
54ebe3cb TL	281	else
54ebe3cb TL	282	#endif
4fc427d9	283	enter_smm_save_state_32(vcpu, &smram.smram32);