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

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