patches/kernel/0011-KVM-x86-emulator-smm-use-smram-struct-for-32-bit-smr.patch

   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
   5  load/restore
   6 MIME-Version: 1.0
   7 Content-Type: text/plain; charset=UTF-8
   8 Content-Transfer-Encoding: 8bit
   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>
  15 Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
  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
  22 index 7294dffa794a..65d82292ccec 100644
  23 --- a/arch/x86/kvm/emulate.c
  24 +++ b/arch/x86/kvm/emulate.c
  25 @@ -2359,25 +2359,17 @@ static void rsm_set_desc_flags(struct desc_struct *desc, u32 flags)
  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,
  31 +                          const struct kvm_smm_seg_state_32 *state,
  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
  57 @@ -2448,63 +2440,46 @@ static int rsm_enter_protected_mode(struct x86_emulate_ctxt *ctxt,
  58  }
  59
  60  static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt,
  61 -                            const char *smstate)
  62 +                            const struct kvm_smram_state_32 *smstate)
  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
 142 @@ -2651,7 +2626,7 @@ static int em_rsm(struct x86_emulate_ctxt *ctxt)
 143                 ret = rsm_load_state_64(ctxt, (const char *)&smram);
 144         else
 145  #endif
 146 -               ret = rsm_load_state_32(ctxt, (const char *)&smram);
 147 +               ret = rsm_load_state_32(ctxt, &smram.smram32);
 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
 152 index 928b3c21b4cb..48a15a71c543 100644
 153 --- a/arch/x86/kvm/x86.c
 154 +++ b/arch/x86/kvm/x86.c
 155 @@ -10121,22 +10121,18 @@ static u32 enter_smm_get_segment_flags(struct kvm_segment *seg)
 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
 186 @@ -10157,54 +10153,47 @@ static void enter_smm_save_seg_64(struct kvm_vcpu *vcpu, char *buf, int n)
 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
 264 @@ -10275,7 +10264,7 @@ static void enter_smm(struct kvm_vcpu *vcpu)
 265                 enter_smm_save_state_64(vcpu, (char *)&smram);
 266         else
 267  #endif
 268 -               enter_smm_save_state_32(vcpu, (char *)&smram);
 269 +               enter_smm_save_state_32(vcpu, &smram.smram32);
 270
 271         /*
 272          * Give enter_smm() a chance to make ISA-specific changes to the vCPU