patches/kernel/0012-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: Wed, 3 Aug 2022 18:50:08 +0300
   4 Subject: [PATCH] KVM: x86: emulator/smm: use smram struct for 64 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_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>
  16 Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
  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
  23 index 65d82292ccec..03f9e5aa036e 100644
  24 --- a/arch/x86/kvm/emulate.c
  25 +++ b/arch/x86/kvm/emulate.c
  26 @@ -2373,24 +2373,16 @@ static void rsm_load_seg_32(struct x86_emulate_ctxt *ctxt,
  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,
  33 +                           const struct kvm_smm_seg_state_64 *state,
  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
  58 @@ -2484,71 +2476,49 @@ static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt,
  59
  60  #ifdef CONFIG_X86_64
  61  static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt,
  62 -                            const char *smstate)
  63 +                            const struct kvm_smram_state_64 *smstate)
  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  }
 151 @@ -2623,7 +2593,7 @@ static int em_rsm(struct x86_emulate_ctxt *ctxt)
 152
 153  #ifdef CONFIG_X86_64
 154         if (emulator_has_longmode(ctxt))
 155 -               ret = rsm_load_state_64(ctxt, (const char *)&smram);
 156 +               ret = rsm_load_state_64(ctxt, &smram.smram64);
 157         else
 158  #endif
 159                 ret = rsm_load_state_32(ctxt, &smram.smram32);
 160 diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
 161 index 48a15a71c543..f5d3c0ff083d 100644
 162 --- a/arch/x86/kvm/x86.c
 163 +++ b/arch/x86/kvm/x86.c
 164 @@ -10136,20 +10136,17 @@ static void enter_smm_save_seg_32(struct kvm_vcpu *vcpu,
 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
 192 @@ -10197,57 +10194,51 @@ static void enter_smm_save_state_32(struct kvm_vcpu *vcpu, struct kvm_smram_stat
 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
 275 @@ -10261,7 +10252,7 @@ static void enter_smm(struct kvm_vcpu *vcpu)
 276         memset(smram.bytes, 0, sizeof(smram.bytes));
 277  #ifdef CONFIG_X86_64
 278         if (guest_cpuid_has(vcpu, X86_FEATURE_LM))
 279 -               enter_smm_save_state_64(vcpu, (char *)&smram);
 280 +               enter_smm_save_state_64(vcpu, &smram.smram64);
 281         else
 282  #endif
 283                 enter_smm_save_state_32(vcpu, &smram.smram32);