1 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
2 From: Maxim Levitsky <mlevitsk@redhat.com>
3 Date: Wed, 3 Aug 2022 18:50:07 +0300
4 Subject: [PATCH] KVM: x86: emulator/smm: use smram struct for 32 bit smram
7 Use kvm_smram_state_32 struct to save/restore 32 bit SMM state
8 (used when X86_FEATURE_LM is not present in the guest CPUID).
10 Signed-off-by: Maxim Levitsky <mlevitsk@redhat.com>
11 Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
13 arch/x86/kvm/emulate.c | 81 +++++++++++++++---------------------------
14 arch/x86/kvm/x86.c | 75 +++++++++++++++++---------------------
15 2 files changed, 60 insertions(+), 96 deletions(-)
17 diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
18 index 730c3e2662d6..ad5d2ab9ab84 100644
19 --- a/arch/x86/kvm/emulate.c
20 +++ b/arch/x86/kvm/emulate.c
21 @@ -2344,25 +2344,17 @@ static void rsm_set_desc_flags(struct desc_struct *desc, u32 flags)
22 desc->type = (flags >> 8) & 15;
25 -static int rsm_load_seg_32(struct x86_emulate_ctxt *ctxt, const char *smstate,
26 +static void rsm_load_seg_32(struct x86_emulate_ctxt *ctxt,
27 + const struct kvm_smm_seg_state_32 *state,
31 struct desc_struct desc;
35 - selector = GET_SMSTATE(u32, smstate, 0x7fa8 + n * 4);
38 - offset = 0x7f84 + n * 12;
40 - offset = 0x7f2c + (n - 3) * 12;
42 - set_desc_base(&desc, GET_SMSTATE(u32, smstate, offset + 8));
43 - set_desc_limit(&desc, GET_SMSTATE(u32, smstate, offset + 4));
44 - rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, offset));
45 + set_desc_base(&desc, state->base);
46 + set_desc_limit(&desc, state->limit);
47 + rsm_set_desc_flags(&desc, state->flags);
48 ctxt->ops->set_segment(ctxt, selector, &desc, 0, n);
49 - return X86EMUL_CONTINUE;
53 @@ -2433,63 +2425,46 @@ static int rsm_enter_protected_mode(struct x86_emulate_ctxt *ctxt,
56 static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt,
57 - const char *smstate)
58 + const struct kvm_smram_state_32 *smstate)
60 - struct desc_struct desc;
63 - u32 val, cr0, cr3, cr4;
66 - cr0 = GET_SMSTATE(u32, smstate, 0x7ffc);
67 - cr3 = GET_SMSTATE(u32, smstate, 0x7ff8);
68 - ctxt->eflags = GET_SMSTATE(u32, smstate, 0x7ff4) | X86_EFLAGS_FIXED;
69 - ctxt->_eip = GET_SMSTATE(u32, smstate, 0x7ff0);
70 + ctxt->eflags = smstate->eflags | X86_EFLAGS_FIXED;
71 + ctxt->_eip = smstate->eip;
73 for (i = 0; i < 8; i++)
74 - *reg_write(ctxt, i) = GET_SMSTATE(u32, smstate, 0x7fd0 + i * 4);
76 - val = GET_SMSTATE(u32, smstate, 0x7fcc);
77 + *reg_write(ctxt, i) = smstate->gprs[i];
79 - if (ctxt->ops->set_dr(ctxt, 6, val))
80 + if (ctxt->ops->set_dr(ctxt, 6, smstate->dr6))
81 return X86EMUL_UNHANDLEABLE;
83 - val = GET_SMSTATE(u32, smstate, 0x7fc8);
85 - if (ctxt->ops->set_dr(ctxt, 7, val))
86 + if (ctxt->ops->set_dr(ctxt, 7, smstate->dr7))
87 return X86EMUL_UNHANDLEABLE;
89 - selector = GET_SMSTATE(u32, smstate, 0x7fc4);
90 - set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7f64));
91 - set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7f60));
92 - rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7f5c));
93 - ctxt->ops->set_segment(ctxt, selector, &desc, 0, VCPU_SREG_TR);
94 + rsm_load_seg_32(ctxt, &smstate->tr, smstate->tr_sel, VCPU_SREG_TR);
95 + rsm_load_seg_32(ctxt, &smstate->ldtr, smstate->ldtr_sel, VCPU_SREG_LDTR);
97 - selector = GET_SMSTATE(u32, smstate, 0x7fc0);
98 - set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7f80));
99 - set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7f7c));
100 - rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7f78));
101 - ctxt->ops->set_segment(ctxt, selector, &desc, 0, VCPU_SREG_LDTR);
103 - dt.address = GET_SMSTATE(u32, smstate, 0x7f74);
104 - dt.size = GET_SMSTATE(u32, smstate, 0x7f70);
105 + dt.address = smstate->gdtr.base;
106 + dt.size = smstate->gdtr.limit;
107 ctxt->ops->set_gdt(ctxt, &dt);
109 - dt.address = GET_SMSTATE(u32, smstate, 0x7f58);
110 - dt.size = GET_SMSTATE(u32, smstate, 0x7f54);
111 + dt.address = smstate->idtr.base;
112 + dt.size = smstate->idtr.limit;
113 ctxt->ops->set_idt(ctxt, &dt);
115 - for (i = 0; i < 6; i++) {
116 - int r = rsm_load_seg_32(ctxt, smstate, i);
117 - if (r != X86EMUL_CONTINUE)
120 + rsm_load_seg_32(ctxt, &smstate->es, smstate->es_sel, VCPU_SREG_ES);
121 + rsm_load_seg_32(ctxt, &smstate->cs, smstate->cs_sel, VCPU_SREG_CS);
122 + rsm_load_seg_32(ctxt, &smstate->ss, smstate->ss_sel, VCPU_SREG_SS);
124 - cr4 = GET_SMSTATE(u32, smstate, 0x7f14);
125 + rsm_load_seg_32(ctxt, &smstate->ds, smstate->ds_sel, VCPU_SREG_DS);
126 + rsm_load_seg_32(ctxt, &smstate->fs, smstate->fs_sel, VCPU_SREG_FS);
127 + rsm_load_seg_32(ctxt, &smstate->gs, smstate->gs_sel, VCPU_SREG_GS);
129 - ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smstate, 0x7ef8));
130 + ctxt->ops->set_smbase(ctxt, smstate->smbase);
132 - return rsm_enter_protected_mode(ctxt, cr0, cr3, cr4);
133 + return rsm_enter_protected_mode(ctxt, smstate->cr0,
134 + smstate->cr3, smstate->cr4);
138 @@ -2636,7 +2611,7 @@ static int em_rsm(struct x86_emulate_ctxt *ctxt)
139 ret = rsm_load_state_64(ctxt, (const char *)&smram);
142 - ret = rsm_load_state_32(ctxt, (const char *)&smram);
143 + ret = rsm_load_state_32(ctxt, &smram.smram32);
145 if (ret != X86EMUL_CONTINUE)
146 goto emulate_shutdown;
147 diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
148 index 2ebbb441880c..8a6b9bffc770 100644
149 --- a/arch/x86/kvm/x86.c
150 +++ b/arch/x86/kvm/x86.c
151 @@ -9018,22 +9018,18 @@ static u32 enter_smm_get_segment_flags(struct kvm_segment *seg)
155 -static void enter_smm_save_seg_32(struct kvm_vcpu *vcpu, char *buf, int n)
156 +static void enter_smm_save_seg_32(struct kvm_vcpu *vcpu,
157 + struct kvm_smm_seg_state_32 *state,
161 struct kvm_segment seg;
164 kvm_get_segment(vcpu, &seg, n);
165 - put_smstate(u32, buf, 0x7fa8 + n * 4, seg.selector);
168 - offset = 0x7f84 + n * 12;
170 - offset = 0x7f2c + (n - 3) * 12;
172 - put_smstate(u32, buf, offset + 8, seg.base);
173 - put_smstate(u32, buf, offset + 4, seg.limit);
174 - put_smstate(u32, buf, offset, enter_smm_get_segment_flags(&seg));
175 + *selector = seg.selector;
176 + state->base = seg.base;
177 + state->limit = seg.limit;
178 + state->flags = enter_smm_get_segment_flags(&seg);
182 @@ -9054,54 +9050,47 @@ static void enter_smm_save_seg_64(struct kvm_vcpu *vcpu, char *buf, int n)
186 -static void enter_smm_save_state_32(struct kvm_vcpu *vcpu, char *buf)
187 +static void enter_smm_save_state_32(struct kvm_vcpu *vcpu, struct kvm_smram_state_32 *smram)
190 - struct kvm_segment seg;
194 - put_smstate(u32, buf, 0x7ffc, kvm_read_cr0(vcpu));
195 - put_smstate(u32, buf, 0x7ff8, kvm_read_cr3(vcpu));
196 - put_smstate(u32, buf, 0x7ff4, kvm_get_rflags(vcpu));
197 - put_smstate(u32, buf, 0x7ff0, kvm_rip_read(vcpu));
198 + smram->cr0 = kvm_read_cr0(vcpu);
199 + smram->cr3 = kvm_read_cr3(vcpu);
200 + smram->eflags = kvm_get_rflags(vcpu);
201 + smram->eip = kvm_rip_read(vcpu);
203 for (i = 0; i < 8; i++)
204 - put_smstate(u32, buf, 0x7fd0 + i * 4, kvm_register_read_raw(vcpu, i));
205 + smram->gprs[i] = kvm_register_read_raw(vcpu, i);
207 kvm_get_dr(vcpu, 6, &val);
208 - put_smstate(u32, buf, 0x7fcc, (u32)val);
209 + smram->dr6 = (u32)val;
210 kvm_get_dr(vcpu, 7, &val);
211 - put_smstate(u32, buf, 0x7fc8, (u32)val);
212 + smram->dr7 = (u32)val;
214 - kvm_get_segment(vcpu, &seg, VCPU_SREG_TR);
215 - put_smstate(u32, buf, 0x7fc4, seg.selector);
216 - put_smstate(u32, buf, 0x7f64, seg.base);
217 - put_smstate(u32, buf, 0x7f60, seg.limit);
218 - put_smstate(u32, buf, 0x7f5c, enter_smm_get_segment_flags(&seg));
220 - kvm_get_segment(vcpu, &seg, VCPU_SREG_LDTR);
221 - put_smstate(u32, buf, 0x7fc0, seg.selector);
222 - put_smstate(u32, buf, 0x7f80, seg.base);
223 - put_smstate(u32, buf, 0x7f7c, seg.limit);
224 - put_smstate(u32, buf, 0x7f78, enter_smm_get_segment_flags(&seg));
225 + enter_smm_save_seg_32(vcpu, &smram->tr, &smram->tr_sel, VCPU_SREG_TR);
226 + enter_smm_save_seg_32(vcpu, &smram->ldtr, &smram->ldtr_sel, VCPU_SREG_LDTR);
228 static_call(kvm_x86_get_gdt)(vcpu, &dt);
229 - put_smstate(u32, buf, 0x7f74, dt.address);
230 - put_smstate(u32, buf, 0x7f70, dt.size);
231 + smram->gdtr.base = dt.address;
232 + smram->gdtr.limit = dt.size;
234 static_call(kvm_x86_get_idt)(vcpu, &dt);
235 - put_smstate(u32, buf, 0x7f58, dt.address);
236 - put_smstate(u32, buf, 0x7f54, dt.size);
237 + smram->idtr.base = dt.address;
238 + smram->idtr.limit = dt.size;
240 - for (i = 0; i < 6; i++)
241 - enter_smm_save_seg_32(vcpu, buf, i);
242 + enter_smm_save_seg_32(vcpu, &smram->es, &smram->es_sel, VCPU_SREG_ES);
243 + enter_smm_save_seg_32(vcpu, &smram->cs, &smram->cs_sel, VCPU_SREG_CS);
244 + enter_smm_save_seg_32(vcpu, &smram->ss, &smram->ss_sel, VCPU_SREG_SS);
246 - put_smstate(u32, buf, 0x7f14, kvm_read_cr4(vcpu));
247 + enter_smm_save_seg_32(vcpu, &smram->ds, &smram->ds_sel, VCPU_SREG_DS);
248 + enter_smm_save_seg_32(vcpu, &smram->fs, &smram->fs_sel, VCPU_SREG_FS);
249 + enter_smm_save_seg_32(vcpu, &smram->gs, &smram->gs_sel, VCPU_SREG_GS);
252 - put_smstate(u32, buf, 0x7efc, 0x00020000);
253 - put_smstate(u32, buf, 0x7ef8, vcpu->arch.smbase);
254 + smram->cr4 = kvm_read_cr4(vcpu);
255 + smram->smm_revision = 0x00020000;
256 + smram->smbase = vcpu->arch.smbase;
260 @@ -9172,7 +9161,7 @@ static void enter_smm(struct kvm_vcpu *vcpu)
261 enter_smm_save_state_64(vcpu, (char *)&smram);
264 - enter_smm_save_state_32(vcpu, (char *)&smram);
265 + enter_smm_save_state_32(vcpu, &smram.smram32);
268 * Give enter_smm() a chance to make ISA-specific changes to the vCPU