[pve-kernel.git] / patches / kernel / 0011-KVM-x86-emulator-smm-use-smram-struct-for-32-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:07 +0300
Subject: [PATCH] KVM: x86: emulator/smm: use smram struct for 32 bit smram
 load/restore
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Use kvm_smram_state_32 struct to save/restore 32 bit SMM state
(used when X86_FEATURE_LM is not present in the guest CPUID).

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 | 81 +++++++++++++++---------------------------
 arch/x86/kvm/x86.c     | 75 +++++++++++++++++---------------------
 2 files changed, 60 insertions(+), 96 deletions(-)

diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
index 7294dffa794a..65d82292ccec 100644
--- a/arch/x86/kvm/emulate.c
+++ b/arch/x86/kvm/emulate.c
@@ -2359,25 +2359,17 @@ static void rsm_set_desc_flags(struct desc_struct *desc, u32 flags)
 	desc->type = (flags >>  8) & 15;
 }
 
-static int rsm_load_seg_32(struct x86_emulate_ctxt *ctxt, const char *smstate,
+static void rsm_load_seg_32(struct x86_emulate_ctxt *ctxt,
+			   const struct kvm_smm_seg_state_32 *state,
+			   u16 selector,
 			   int n)
 {
 	struct desc_struct desc;
-	int offset;
-	u16 selector;
-
-	selector = GET_SMSTATE(u32, smstate, 0x7fa8 + n * 4);
-
-	if (n < 3)
-		offset = 0x7f84 + n * 12;
-	else
-		offset = 0x7f2c + (n - 3) * 12;
 
-	set_desc_base(&desc,      GET_SMSTATE(u32, smstate, offset + 8));
-	set_desc_limit(&desc,     GET_SMSTATE(u32, smstate, offset + 4));
-	rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, offset));
+	set_desc_base(&desc,      state->base);
+	set_desc_limit(&desc,     state->limit);
+	rsm_set_desc_flags(&desc, state->flags);
 	ctxt->ops->set_segment(ctxt, selector, &desc, 0, n);
-	return X86EMUL_CONTINUE;
 }
 
 #ifdef CONFIG_X86_64
@@ -2448,63 +2440,46 @@ static int rsm_enter_protected_mode(struct x86_emulate_ctxt *ctxt,
 }
 
 static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt,
-			     const char *smstate)
+			     const struct kvm_smram_state_32 *smstate)
 {
-	struct desc_struct desc;
 	struct desc_ptr dt;
-	u16 selector;
-	u32 val, cr0, cr3, cr4;
 	int i;
 
-	cr0 =                      GET_SMSTATE(u32, smstate, 0x7ffc);
-	cr3 =                      GET_SMSTATE(u32, smstate, 0x7ff8);
-	ctxt->eflags =             GET_SMSTATE(u32, smstate, 0x7ff4) | X86_EFLAGS_FIXED;
-	ctxt->_eip =               GET_SMSTATE(u32, smstate, 0x7ff0);
+	ctxt->eflags =  smstate->eflags | X86_EFLAGS_FIXED;
+	ctxt->_eip =  smstate->eip;
 
 	for (i = 0; i < 8; i++)
-		*reg_write(ctxt, i) = GET_SMSTATE(u32, smstate, 0x7fd0 + i * 4);
-
-	val = GET_SMSTATE(u32, smstate, 0x7fcc);
+		*reg_write(ctxt, i) = smstate->gprs[i];
 
-	if (ctxt->ops->set_dr(ctxt, 6, val))
+	if (ctxt->ops->set_dr(ctxt, 6, smstate->dr6))
 		return X86EMUL_UNHANDLEABLE;
-
-	val = GET_SMSTATE(u32, smstate, 0x7fc8);
-
-	if (ctxt->ops->set_dr(ctxt, 7, val))
+	if (ctxt->ops->set_dr(ctxt, 7, smstate->dr7))
 		return X86EMUL_UNHANDLEABLE;
 
-	selector =                 GET_SMSTATE(u32, smstate, 0x7fc4);
-	set_desc_base(&desc,       GET_SMSTATE(u32, smstate, 0x7f64));
-	set_desc_limit(&desc,      GET_SMSTATE(u32, smstate, 0x7f60));
-	rsm_set_desc_flags(&desc,  GET_SMSTATE(u32, smstate, 0x7f5c));
-	ctxt->ops->set_segment(ctxt, selector, &desc, 0, VCPU_SREG_TR);
+	rsm_load_seg_32(ctxt, &smstate->tr, smstate->tr_sel, VCPU_SREG_TR);
+	rsm_load_seg_32(ctxt, &smstate->ldtr, smstate->ldtr_sel, VCPU_SREG_LDTR);
 
-	selector =                 GET_SMSTATE(u32, smstate, 0x7fc0);
-	set_desc_base(&desc,       GET_SMSTATE(u32, smstate, 0x7f80));
-	set_desc_limit(&desc,      GET_SMSTATE(u32, smstate, 0x7f7c));
-	rsm_set_desc_flags(&desc,  GET_SMSTATE(u32, smstate, 0x7f78));
-	ctxt->ops->set_segment(ctxt, selector, &desc, 0, VCPU_SREG_LDTR);
 
-	dt.address =               GET_SMSTATE(u32, smstate, 0x7f74);
-	dt.size =                  GET_SMSTATE(u32, smstate, 0x7f70);
+	dt.address =               smstate->gdtr.base;
+	dt.size =                  smstate->gdtr.limit;
 	ctxt->ops->set_gdt(ctxt, &dt);
 
-	dt.address =               GET_SMSTATE(u32, smstate, 0x7f58);
-	dt.size =                  GET_SMSTATE(u32, smstate, 0x7f54);
+	dt.address =               smstate->idtr.base;
+	dt.size =                  smstate->idtr.limit;
 	ctxt->ops->set_idt(ctxt, &dt);
 
-	for (i = 0; i < 6; i++) {
-		int r = rsm_load_seg_32(ctxt, smstate, i);
-		if (r != X86EMUL_CONTINUE)
-			return r;
-	}
+	rsm_load_seg_32(ctxt, &smstate->es, smstate->es_sel, VCPU_SREG_ES);
+	rsm_load_seg_32(ctxt, &smstate->cs, smstate->cs_sel, VCPU_SREG_CS);
+	rsm_load_seg_32(ctxt, &smstate->ss, smstate->ss_sel, VCPU_SREG_SS);
 
-	cr4 = GET_SMSTATE(u32, smstate, 0x7f14);
+	rsm_load_seg_32(ctxt, &smstate->ds, smstate->ds_sel, VCPU_SREG_DS);
+	rsm_load_seg_32(ctxt, &smstate->fs, smstate->fs_sel, VCPU_SREG_FS);
+	rsm_load_seg_32(ctxt, &smstate->gs, smstate->gs_sel, VCPU_SREG_GS);
 
-	ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smstate, 0x7ef8));
+	ctxt->ops->set_smbase(ctxt, smstate->smbase);
 
-	return rsm_enter_protected_mode(ctxt, cr0, cr3, cr4);
+	return rsm_enter_protected_mode(ctxt, smstate->cr0,
+					smstate->cr3, smstate->cr4);
 }
 
 #ifdef CONFIG_X86_64
@@ -2651,7 +2626,7 @@ static int em_rsm(struct x86_emulate_ctxt *ctxt)
 		ret = rsm_load_state_64(ctxt, (const char *)&smram);
 	else
 #endif
-		ret = rsm_load_state_32(ctxt, (const char *)&smram);
+		ret = rsm_load_state_32(ctxt, &smram.smram32);
 
 	if (ret != X86EMUL_CONTINUE)
 		goto emulate_shutdown;
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 928b3c21b4cb..48a15a71c543 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -10121,22 +10121,18 @@ static u32 enter_smm_get_segment_flags(struct kvm_segment *seg)
 	return flags;
 }
 
-static void enter_smm_save_seg_32(struct kvm_vcpu *vcpu, char *buf, int n)
+static void enter_smm_save_seg_32(struct kvm_vcpu *vcpu,
+					 struct kvm_smm_seg_state_32 *state,
+					 u32 *selector,
+					 int n)
 {
 	struct kvm_segment seg;
-	int offset;
 
 	kvm_get_segment(vcpu, &seg, n);
-	put_smstate(u32, buf, 0x7fa8 + n * 4, seg.selector);
-
-	if (n < 3)
-		offset = 0x7f84 + n * 12;
-	else
-		offset = 0x7f2c + (n - 3) * 12;
-
-	put_smstate(u32, buf, offset + 8, seg.base);
-	put_smstate(u32, buf, offset + 4, seg.limit);
-	put_smstate(u32, buf, offset, enter_smm_get_segment_flags(&seg));
+	*selector = seg.selector;
+	state->base = seg.base;
+	state->limit = seg.limit;
+	state->flags = enter_smm_get_segment_flags(&seg);
 }
 
 #ifdef CONFIG_X86_64
@@ -10157,54 +10153,47 @@ static void enter_smm_save_seg_64(struct kvm_vcpu *vcpu, char *buf, int n)
 }
 #endif
 
-static void enter_smm_save_state_32(struct kvm_vcpu *vcpu, char *buf)
+static void enter_smm_save_state_32(struct kvm_vcpu *vcpu, struct kvm_smram_state_32 *smram)
 {
 	struct desc_ptr dt;
-	struct kvm_segment seg;
 	unsigned long val;
 	int i;
 
-	put_smstate(u32, buf, 0x7ffc, kvm_read_cr0(vcpu));
-	put_smstate(u32, buf, 0x7ff8, kvm_read_cr3(vcpu));
-	put_smstate(u32, buf, 0x7ff4, kvm_get_rflags(vcpu));
-	put_smstate(u32, buf, 0x7ff0, kvm_rip_read(vcpu));
+	smram->cr0     = kvm_read_cr0(vcpu);
+	smram->cr3     = kvm_read_cr3(vcpu);
+	smram->eflags  = kvm_get_rflags(vcpu);
+	smram->eip     = kvm_rip_read(vcpu);
 
 	for (i = 0; i < 8; i++)
-		put_smstate(u32, buf, 0x7fd0 + i * 4, kvm_register_read_raw(vcpu, i));
+		smram->gprs[i] = kvm_register_read_raw(vcpu, i);
 
 	kvm_get_dr(vcpu, 6, &val);
-	put_smstate(u32, buf, 0x7fcc, (u32)val);
+	smram->dr6     = (u32)val;
 	kvm_get_dr(vcpu, 7, &val);
-	put_smstate(u32, buf, 0x7fc8, (u32)val);
+	smram->dr7     = (u32)val;
 
-	kvm_get_segment(vcpu, &seg, VCPU_SREG_TR);
-	put_smstate(u32, buf, 0x7fc4, seg.selector);
-	put_smstate(u32, buf, 0x7f64, seg.base);
-	put_smstate(u32, buf, 0x7f60, seg.limit);
-	put_smstate(u32, buf, 0x7f5c, enter_smm_get_segment_flags(&seg));
-
-	kvm_get_segment(vcpu, &seg, VCPU_SREG_LDTR);
-	put_smstate(u32, buf, 0x7fc0, seg.selector);
-	put_smstate(u32, buf, 0x7f80, seg.base);
-	put_smstate(u32, buf, 0x7f7c, seg.limit);
-	put_smstate(u32, buf, 0x7f78, enter_smm_get_segment_flags(&seg));
+	enter_smm_save_seg_32(vcpu, &smram->tr, &smram->tr_sel, VCPU_SREG_TR);
+	enter_smm_save_seg_32(vcpu, &smram->ldtr, &smram->ldtr_sel, VCPU_SREG_LDTR);
 
 	static_call(kvm_x86_get_gdt)(vcpu, &dt);
-	put_smstate(u32, buf, 0x7f74, dt.address);
-	put_smstate(u32, buf, 0x7f70, dt.size);
+	smram->gdtr.base = dt.address;
+	smram->gdtr.limit = dt.size;
 
 	static_call(kvm_x86_get_idt)(vcpu, &dt);
-	put_smstate(u32, buf, 0x7f58, dt.address);
-	put_smstate(u32, buf, 0x7f54, dt.size);
+	smram->idtr.base = dt.address;
+	smram->idtr.limit = dt.size;
 
-	for (i = 0; i < 6; i++)
-		enter_smm_save_seg_32(vcpu, buf, i);
+	enter_smm_save_seg_32(vcpu, &smram->es, &smram->es_sel, VCPU_SREG_ES);
+	enter_smm_save_seg_32(vcpu, &smram->cs, &smram->cs_sel, VCPU_SREG_CS);
+	enter_smm_save_seg_32(vcpu, &smram->ss, &smram->ss_sel, VCPU_SREG_SS);
 
-	put_smstate(u32, buf, 0x7f14, kvm_read_cr4(vcpu));
+	enter_smm_save_seg_32(vcpu, &smram->ds, &smram->ds_sel, VCPU_SREG_DS);
+	enter_smm_save_seg_32(vcpu, &smram->fs, &smram->fs_sel, VCPU_SREG_FS);
+	enter_smm_save_seg_32(vcpu, &smram->gs, &smram->gs_sel, VCPU_SREG_GS);
 
-	/* revision id */
-	put_smstate(u32, buf, 0x7efc, 0x00020000);
-	put_smstate(u32, buf, 0x7ef8, vcpu->arch.smbase);
+	smram->cr4 = kvm_read_cr4(vcpu);
+	smram->smm_revision = 0x00020000;
+	smram->smbase = vcpu->arch.smbase;
 }
 
 #ifdef CONFIG_X86_64
@@ -10275,7 +10264,7 @@ static void enter_smm(struct kvm_vcpu *vcpu)
 		enter_smm_save_state_64(vcpu, (char *)&smram);
 	else
 #endif
-		enter_smm_save_state_32(vcpu, (char *)&smram);
+		enter_smm_save_state_32(vcpu, &smram.smram32);
 
 	/*
 	 * Give enter_smm() a chance to make ISA-specific changes to the vCPU
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:07 +0300
54ebe3cb TL	4	Subject: [PATCH] KVM: x86: emulator/smm: use smram struct for 32 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_32 struct to save/restore 32 bit SMM state
	11	(used when X86_FEATURE_LM is not present in the guest CPUID).
	12
	13	Signed-off-by: Maxim Levitsky <mlevitsk@redhat.com>
	14	Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
826eb0ff	15	Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
54ebe3cb TL	16	---
	17	arch/x86/kvm/emulate.c \| 81 +++++++++++++++---------------------------
	18	arch/x86/kvm/x86.c \| 75 +++++++++++++++++---------------------
	19	2 files changed, 60 insertions(+), 96 deletions(-)
	20
	21	diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
12247ad0	22	index 7294dffa794a..65d82292ccec 100644
54ebe3cb TL	23	--- a/arch/x86/kvm/emulate.c
54ebe3cb TL	24	+++ b/arch/x86/kvm/emulate.c
4fc427d9	25	@@ -2359,25 +2359,17 @@ static void rsm_set_desc_flags(struct desc_struct *desc, u32 flags)
54ebe3cb TL	26	desc->type = (flags >> 8) & 15;
	27	}
	28
	29	-static int rsm_load_seg_32(struct x86_emulate_ctxt ctxt, const char smstate,
	30	+static void rsm_load_seg_32(struct x86_emulate_ctxt *ctxt,
4fc427d9	31	+ const struct kvm_smm_seg_state_32 *state,
54ebe3cb TL	32	+ u16 selector,
	33	int n)
	34	{
	35	struct desc_struct desc;
	36	- int offset;
	37	- u16 selector;
	38	-
	39	- selector = GET_SMSTATE(u32, smstate, 0x7fa8 + n * 4);
	40	-
	41	- if (n < 3)
	42	- offset = 0x7f84 + n * 12;
	43	- else
	44	- offset = 0x7f2c + (n - 3) * 12;
	45
	46	- set_desc_base(&desc, GET_SMSTATE(u32, smstate, offset + 8));
	47	- set_desc_limit(&desc, GET_SMSTATE(u32, smstate, offset + 4));
	48	- rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, offset));
	49	+ set_desc_base(&desc, state->base);
	50	+ set_desc_limit(&desc, state->limit);
	51	+ rsm_set_desc_flags(&desc, state->flags);
	52	ctxt->ops->set_segment(ctxt, selector, &desc, 0, n);
	53	- return X86EMUL_CONTINUE;
	54	}
	55
	56	#ifdef CONFIG_X86_64
4fc427d9	57	@@ -2448,63 +2440,46 @@ static int rsm_enter_protected_mode(struct x86_emulate_ctxt *ctxt,
54ebe3cb TL	58	}
	59
	60	static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt,
	61	- const char *smstate)
4fc427d9	62	+ const struct kvm_smram_state_32 *smstate)
54ebe3cb TL	63	{
	64	- struct desc_struct desc;
	65	struct desc_ptr dt;
	66	- u16 selector;
	67	- u32 val, cr0, cr3, cr4;
	68	int i;
	69
	70	- cr0 = GET_SMSTATE(u32, smstate, 0x7ffc);
	71	- cr3 = GET_SMSTATE(u32, smstate, 0x7ff8);
	72	- ctxt->eflags = GET_SMSTATE(u32, smstate, 0x7ff4) \| X86_EFLAGS_FIXED;
	73	- ctxt->_eip = GET_SMSTATE(u32, smstate, 0x7ff0);
	74	+ ctxt->eflags = smstate->eflags \| X86_EFLAGS_FIXED;
	75	+ ctxt->_eip = smstate->eip;
	76
	77	for (i = 0; i < 8; i++)
	78	- reg_write(ctxt, i) = GET_SMSTATE(u32, smstate, 0x7fd0 + i 4);
	79	-
	80	- val = GET_SMSTATE(u32, smstate, 0x7fcc);
	81	+ *reg_write(ctxt, i) = smstate->gprs[i];
	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(u32, smstate, 0x7fc8);
	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	- selector = GET_SMSTATE(u32, smstate, 0x7fc4);
	94	- set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7f64));
	95	- set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7f60));
	96	- rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7f5c));
	97	- ctxt->ops->set_segment(ctxt, selector, &desc, 0, VCPU_SREG_TR);
	98	+ rsm_load_seg_32(ctxt, &smstate->tr, smstate->tr_sel, VCPU_SREG_TR);
	99	+ rsm_load_seg_32(ctxt, &smstate->ldtr, smstate->ldtr_sel, VCPU_SREG_LDTR);
	100
	101	- selector = GET_SMSTATE(u32, smstate, 0x7fc0);
	102	- set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7f80));
	103	- set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7f7c));
	104	- rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7f78));
	105	- ctxt->ops->set_segment(ctxt, selector, &desc, 0, VCPU_SREG_LDTR);
	106
	107	- dt.address = GET_SMSTATE(u32, smstate, 0x7f74);
	108	- dt.size = GET_SMSTATE(u32, smstate, 0x7f70);
	109	+ dt.address = smstate->gdtr.base;
	110	+ dt.size = smstate->gdtr.limit;
	111	ctxt->ops->set_gdt(ctxt, &dt);
	112
	113	- dt.address = GET_SMSTATE(u32, smstate, 0x7f58);
	114	- dt.size = GET_SMSTATE(u32, smstate, 0x7f54);
	115	+ dt.address = smstate->idtr.base;
	116	+ dt.size = smstate->idtr.limit;
	117	ctxt->ops->set_idt(ctxt, &dt);
	118
	119	- for (i = 0; i < 6; i++) {
	120	- int r = rsm_load_seg_32(ctxt, smstate, i);
	121	- if (r != X86EMUL_CONTINUE)
	122	- return r;
	123	- }
	124	+ rsm_load_seg_32(ctxt, &smstate->es, smstate->es_sel, VCPU_SREG_ES);
	125	+ rsm_load_seg_32(ctxt, &smstate->cs, smstate->cs_sel, VCPU_SREG_CS);
	126	+ rsm_load_seg_32(ctxt, &smstate->ss, smstate->ss_sel, VCPU_SREG_SS);
127
128	- cr4 = GET_SMSTATE(u32, smstate, 0x7f14);
129	+ rsm_load_seg_32(ctxt, &smstate->ds, smstate->ds_sel, VCPU_SREG_DS);
130	+ rsm_load_seg_32(ctxt, &smstate->fs, smstate->fs_sel, VCPU_SREG_FS);
131	+ rsm_load_seg_32(ctxt, &smstate->gs, smstate->gs_sel, VCPU_SREG_GS);
132
133	- ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smstate, 0x7ef8));
134	+ ctxt->ops->set_smbase(ctxt, smstate->smbase);
135
136	- return rsm_enter_protected_mode(ctxt, cr0, cr3, cr4);
137	+ return rsm_enter_protected_mode(ctxt, smstate->cr0,
138	+ smstate->cr3, smstate->cr4);
139	}
140
141	#ifdef CONFIG_X86_64
4fc427d9 TL	142	@@ -2651,7 +2626,7 @@ static int em_rsm(struct x86_emulate_ctxt *ctxt)
4fc427d9 TL	143	ret = rsm_load_state_64(ctxt, (const char *)&smram);
54ebe3cb TL	144	else
54ebe3cb TL	145	#endif
4fc427d9 TL	146	- ret = rsm_load_state_32(ctxt, (const char *)&smram);
4fc427d9 TL	147	+ ret = rsm_load_state_32(ctxt, &smram.smram32);
54ebe3cb TL	148
	149	if (ret != X86EMUL_CONTINUE)
	150	goto emulate_shutdown;
	151	diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
fc2b61b1	152	index 928b3c21b4cb..48a15a71c543 100644
54ebe3cb TL	153	--- a/arch/x86/kvm/x86.c
54ebe3cb TL	154	+++ b/arch/x86/kvm/x86.c
fc2b61b1	155	@@ -10121,22 +10121,18 @@ static u32 enter_smm_get_segment_flags(struct kvm_segment *seg)
54ebe3cb TL	156	return flags;
	157	}
	158
	159	-static void enter_smm_save_seg_32(struct kvm_vcpu vcpu, char buf, int n)
	160	+static void enter_smm_save_seg_32(struct kvm_vcpu *vcpu,
	161	+ struct kvm_smm_seg_state_32 *state,
	162	+ u32 *selector,
	163	+ int n)
	164	{
	165	struct kvm_segment seg;
	166	- int offset;
	167
	168	kvm_get_segment(vcpu, &seg, n);
	169	- put_smstate(u32, buf, 0x7fa8 + n * 4, seg.selector);
	170	-
	171	- if (n < 3)
	172	- offset = 0x7f84 + n * 12;
	173	- else
	174	- offset = 0x7f2c + (n - 3) * 12;
	175	-
	176	- put_smstate(u32, buf, offset + 8, seg.base);
	177	- put_smstate(u32, buf, offset + 4, seg.limit);
	178	- put_smstate(u32, buf, offset, enter_smm_get_segment_flags(&seg));
	179	+ *selector = seg.selector;
	180	+ state->base = seg.base;
	181	+ state->limit = seg.limit;
	182	+ state->flags = enter_smm_get_segment_flags(&seg);
	183	}
	184
	185	#ifdef CONFIG_X86_64
fc2b61b1	186	@@ -10157,54 +10153,47 @@ static void enter_smm_save_seg_64(struct kvm_vcpu vcpu, char buf, int n)
54ebe3cb TL	187	}
	188	#endif
	189
	190	-static void enter_smm_save_state_32(struct kvm_vcpu vcpu, char buf)
	191	+static void enter_smm_save_state_32(struct kvm_vcpu vcpu, struct kvm_smram_state_32 smram)
	192	{
	193	struct desc_ptr dt;
	194	- struct kvm_segment seg;
	195	unsigned long val;
	196	int i;
	197
	198	- put_smstate(u32, buf, 0x7ffc, kvm_read_cr0(vcpu));
	199	- put_smstate(u32, buf, 0x7ff8, kvm_read_cr3(vcpu));
	200	- put_smstate(u32, buf, 0x7ff4, kvm_get_rflags(vcpu));
	201	- put_smstate(u32, buf, 0x7ff0, kvm_rip_read(vcpu));
	202	+ smram->cr0 = kvm_read_cr0(vcpu);
	203	+ smram->cr3 = kvm_read_cr3(vcpu);
	204	+ smram->eflags = kvm_get_rflags(vcpu);
	205	+ smram->eip = kvm_rip_read(vcpu);
	206
	207	for (i = 0; i < 8; i++)
	208	- put_smstate(u32, buf, 0x7fd0 + i * 4, kvm_register_read_raw(vcpu, i));
	209	+ smram->gprs[i] = kvm_register_read_raw(vcpu, i);
	210
	211	kvm_get_dr(vcpu, 6, &val);
	212	- put_smstate(u32, buf, 0x7fcc, (u32)val);
	213	+ smram->dr6 = (u32)val;
	214	kvm_get_dr(vcpu, 7, &val);
	215	- put_smstate(u32, buf, 0x7fc8, (u32)val);
	216	+ smram->dr7 = (u32)val;
	217
	218	- kvm_get_segment(vcpu, &seg, VCPU_SREG_TR);
	219	- put_smstate(u32, buf, 0x7fc4, seg.selector);
	220	- put_smstate(u32, buf, 0x7f64, seg.base);
	221	- put_smstate(u32, buf, 0x7f60, seg.limit);
	222	- put_smstate(u32, buf, 0x7f5c, enter_smm_get_segment_flags(&seg));
	223	-
	224	- kvm_get_segment(vcpu, &seg, VCPU_SREG_LDTR);
	225	- put_smstate(u32, buf, 0x7fc0, seg.selector);
	226	- put_smstate(u32, buf, 0x7f80, seg.base);
	227	- put_smstate(u32, buf, 0x7f7c, seg.limit);
	228	- put_smstate(u32, buf, 0x7f78, enter_smm_get_segment_flags(&seg));
	229	+ enter_smm_save_seg_32(vcpu, &smram->tr, &smram->tr_sel, VCPU_SREG_TR);
	230	+ enter_smm_save_seg_32(vcpu, &smram->ldtr, &smram->ldtr_sel, VCPU_SREG_LDTR);
	231
	232	static_call(kvm_x86_get_gdt)(vcpu, &dt);
	233	- put_smstate(u32, buf, 0x7f74, dt.address);
	234	- put_smstate(u32, buf, 0x7f70, dt.size);
	235	+ smram->gdtr.base = dt.address;
	236	+ smram->gdtr.limit = dt.size;
	237
	238	static_call(kvm_x86_get_idt)(vcpu, &dt);
	239	- put_smstate(u32, buf, 0x7f58, dt.address);
	240	- put_smstate(u32, buf, 0x7f54, dt.size);
	241	+ smram->idtr.base = dt.address;
	242	+ smram->idtr.limit = dt.size;
	243
	244	- for (i = 0; i < 6; i++)
	245	- enter_smm_save_seg_32(vcpu, buf, i);
	246	+ enter_smm_save_seg_32(vcpu, &smram->es, &smram->es_sel, VCPU_SREG_ES);
	247	+ enter_smm_save_seg_32(vcpu, &smram->cs, &smram->cs_sel, VCPU_SREG_CS);
	248	+ enter_smm_save_seg_32(vcpu, &smram->ss, &smram->ss_sel, VCPU_SREG_SS);
	249
	250	- put_smstate(u32, buf, 0x7f14, kvm_read_cr4(vcpu));
251	+ enter_smm_save_seg_32(vcpu, &smram->ds, &smram->ds_sel, VCPU_SREG_DS);
252	+ enter_smm_save_seg_32(vcpu, &smram->fs, &smram->fs_sel, VCPU_SREG_FS);
253	+ enter_smm_save_seg_32(vcpu, &smram->gs, &smram->gs_sel, VCPU_SREG_GS);
254
255	- /* revision id */
256	- put_smstate(u32, buf, 0x7efc, 0x00020000);
257	- put_smstate(u32, buf, 0x7ef8, vcpu->arch.smbase);
258	+ smram->cr4 = kvm_read_cr4(vcpu);
259	+ smram->smm_revision = 0x00020000;
260	+ smram->smbase = vcpu->arch.smbase;
261	}
262
263	#ifdef CONFIG_X86_64
fc2b61b1	264	@@ -10275,7 +10264,7 @@ static void enter_smm(struct kvm_vcpu *vcpu)
4fc427d9	265	enter_smm_save_state_64(vcpu, (char *)&smram);
54ebe3cb TL	266	else
54ebe3cb TL	267	#endif
4fc427d9 TL	268	- enter_smm_save_state_32(vcpu, (char *)&smram);
4fc427d9 TL	269	+ enter_smm_save_state_32(vcpu, &smram.smram32);
54ebe3cb TL	270
	271	/*
	272	* Give enter_smm() a chance to make ISA-specific changes to the vCPU