arch/x86/kvm/mtrr.c

   1 /*
   2  * vMTRR implementation
   3  *
   4  * Copyright (C) 2006 Qumranet, Inc.
   5  * Copyright 2010 Red Hat, Inc. and/or its affiliates.
   6  * Copyright(C) 2015 Intel Corporation.
   7  *
   8  * Authors:
   9  *   Yaniv Kamay  <yaniv@qumranet.com>
  10  *   Avi Kivity   <avi@qumranet.com>
  11  *   Marcelo Tosatti <mtosatti@redhat.com>
  12  *   Paolo Bonzini <pbonzini@redhat.com>
  13  *   Xiao Guangrong <guangrong.xiao@linux.intel.com>
  14  *
  15  * This work is licensed under the terms of the GNU GPL, version 2.  See
  16  * the COPYING file in the top-level directory.
  17  */
  18
  19 #include <linux/kvm_host.h>
  20 #include <asm/mtrr.h>
  21
  22 #include "cpuid.h"
  23 #include "mmu.h"
  24
  25 #define IA32_MTRR_DEF_TYPE_E            (1ULL << 11)
  26 #define IA32_MTRR_DEF_TYPE_FE           (1ULL << 10)
  27 #define IA32_MTRR_DEF_TYPE_TYPE_MASK    (0xff)
  28
  29 static bool msr_mtrr_valid(unsigned msr)
  30 {
  31         switch (msr) {
  32         case 0x200 ... 0x200 + 2 * KVM_NR_VAR_MTRR - 1:
  33         case MSR_MTRRfix64K_00000:
  34         case MSR_MTRRfix16K_80000:
  35         case MSR_MTRRfix16K_A0000:
  36         case MSR_MTRRfix4K_C0000:
  37         case MSR_MTRRfix4K_C8000:
  38         case MSR_MTRRfix4K_D0000:
  39         case MSR_MTRRfix4K_D8000:
  40         case MSR_MTRRfix4K_E0000:
  41         case MSR_MTRRfix4K_E8000:
  42         case MSR_MTRRfix4K_F0000:
  43         case MSR_MTRRfix4K_F8000:
  44         case MSR_MTRRdefType:
  45         case MSR_IA32_CR_PAT:
  46                 return true;
  47         case 0x2f8:
  48                 return true;
  49         }
  50         return false;
  51 }
  52
  53 static bool valid_pat_type(unsigned t)
  54 {
  55         return t < 8 && (1 << t) & 0xf3; /* 0, 1, 4, 5, 6, 7 */
  56 }
  57
  58 static bool valid_mtrr_type(unsigned t)
  59 {
  60         return t < 8 && (1 << t) & 0x73; /* 0, 1, 4, 5, 6 */
  61 }
  62
  63 bool kvm_mtrr_valid(struct kvm_vcpu *vcpu, u32 msr, u64 data)
  64 {
  65         int i;
  66         u64 mask;
  67
  68         if (!msr_mtrr_valid(msr))
  69                 return false;
  70
  71         if (msr == MSR_IA32_CR_PAT) {
  72                 for (i = 0; i < 8; i++)
  73                         if (!valid_pat_type((data >> (i * 8)) & 0xff))
  74                                 return false;
  75                 return true;
  76         } else if (msr == MSR_MTRRdefType) {
  77                 if (data & ~0xcff)
  78                         return false;
  79                 return valid_mtrr_type(data & 0xff);
  80         } else if (msr >= MSR_MTRRfix64K_00000 && msr <= MSR_MTRRfix4K_F8000) {
  81                 for (i = 0; i < 8 ; i++)
  82                         if (!valid_mtrr_type((data >> (i * 8)) & 0xff))
  83                                 return false;
  84                 return true;
  85         }
  86
  87         /* variable MTRRs */
  88         WARN_ON(!(msr >= 0x200 && msr < 0x200 + 2 * KVM_NR_VAR_MTRR));
  89
  90         mask = (~0ULL) << cpuid_maxphyaddr(vcpu);
  91         if ((msr & 1) == 0) {
  92                 /* MTRR base */
  93                 if (!valid_mtrr_type(data & 0xff))
  94                         return false;
  95                 mask |= 0xf00;
  96         } else
  97                 /* MTRR mask */
  98                 mask |= 0x7ff;
  99         if (data & mask) {
 100                 kvm_inject_gp(vcpu, 0);
 101                 return false;
 102         }
 103
 104         return true;
 105 }
 106 EXPORT_SYMBOL_GPL(kvm_mtrr_valid);
 107
 108 static bool mtrr_is_enabled(struct kvm_mtrr *mtrr_state)
 109 {
 110         return !!(mtrr_state->deftype & IA32_MTRR_DEF_TYPE_E);
 111 }
 112
 113 static bool fixed_mtrr_is_enabled(struct kvm_mtrr *mtrr_state)
 114 {
 115         return !!(mtrr_state->deftype & IA32_MTRR_DEF_TYPE_FE);
 116 }
 117
 118 static u8 mtrr_default_type(struct kvm_mtrr *mtrr_state)
 119 {
 120         return mtrr_state->deftype & IA32_MTRR_DEF_TYPE_TYPE_MASK;
 121 }
 122
 123 static u8 mtrr_disabled_type(void)
 124 {
 125         /*
 126          * Intel SDM 11.11.2.2: all MTRRs are disabled when
 127          * IA32_MTRR_DEF_TYPE.E bit is cleared, and the UC
 128          * memory type is applied to all of physical memory.
 129          */
 130         return MTRR_TYPE_UNCACHABLE;
 131 }
 132
 133 /*
 134 * Three terms are used in the following code:
 135 * - segment, it indicates the address segments covered by fixed MTRRs.
 136 * - unit, it corresponds to the MSR entry in the segment.
 137 * - range, a range is covered in one memory cache type.
 138 */
 139 struct fixed_mtrr_segment {
 140         u64 start;
 141         u64 end;
 142
 143         int range_shift;
 144
 145         /* the start position in kvm_mtrr.fixed_ranges[]. */
 146         int range_start;
 147 };
 148
 149 static struct fixed_mtrr_segment fixed_seg_table[] = {
 150         /* MSR_MTRRfix64K_00000, 1 unit. 64K fixed mtrr. */
 151         {
 152                 .start = 0x0,
 153                 .end = 0x80000,
 154                 .range_shift = 16, /* 64K */
 155                 .range_start = 0,
 156         },
 157
 158         /*
 159          * MSR_MTRRfix16K_80000 ... MSR_MTRRfix16K_A0000, 2 units,
 160          * 16K fixed mtrr.
 161          */
 162         {
 163                 .start = 0x80000,
 164                 .end = 0xc0000,
 165                 .range_shift = 14, /* 16K */
 166                 .range_start = 8,
 167         },
 168
 169         /*
 170          * MSR_MTRRfix4K_C0000 ... MSR_MTRRfix4K_F8000, 8 units,
 171          * 4K fixed mtrr.
 172          */
 173         {
 174                 .start = 0xc0000,
 175                 .end = 0x100000,
 176                 .range_shift = 12, /* 12K */
 177                 .range_start = 24,
 178         }
 179 };
 180
 181 /*
 182  * The size of unit is covered in one MSR, one MSR entry contains
 183  * 8 ranges so that unit size is always 8 * 2^range_shift.
 184  */
 185 static u64 fixed_mtrr_seg_unit_size(int seg)
 186 {
 187         return 8 << fixed_seg_table[seg].range_shift;
 188 }
 189
 190 static bool fixed_msr_to_seg_unit(u32 msr, int *seg, int *unit)
 191 {
 192         switch (msr) {
 193         case MSR_MTRRfix64K_00000:
 194                 *seg = 0;
 195                 *unit = 0;
 196                 break;
 197         case MSR_MTRRfix16K_80000 ... MSR_MTRRfix16K_A0000:
 198                 *seg = 1;
 199                 *unit = msr - MSR_MTRRfix16K_80000;
 200                 break;
 201         case MSR_MTRRfix4K_C0000 ... MSR_MTRRfix4K_F8000:
 202                 *seg = 2;
 203                 *unit = msr - MSR_MTRRfix4K_C0000;
 204                 break;
 205         default:
 206                 return false;
 207         }
 208
 209         return true;
 210 }
 211
 212 static void fixed_mtrr_seg_unit_range(int seg, int unit, u64 *start, u64 *end)
 213 {
 214         struct fixed_mtrr_segment *mtrr_seg = &fixed_seg_table[seg];
 215         u64 unit_size = fixed_mtrr_seg_unit_size(seg);
 216
 217         *start = mtrr_seg->start + unit * unit_size;
 218         *end = *start + unit_size;
 219         WARN_ON(*end > mtrr_seg->end);
 220 }
 221
 222 static int fixed_mtrr_seg_unit_range_index(int seg, int unit)
 223 {
 224         struct fixed_mtrr_segment *mtrr_seg = &fixed_seg_table[seg];
 225
 226         WARN_ON(mtrr_seg->start + unit * fixed_mtrr_seg_unit_size(seg)
 227                 > mtrr_seg->end);
 228
 229         /* each unit has 8 ranges. */
 230         return mtrr_seg->range_start + 8 * unit;
 231 }
 232
 233 static int fixed_mtrr_seg_end_range_index(int seg)
 234 {
 235         struct fixed_mtrr_segment *mtrr_seg = &fixed_seg_table[seg];
 236         int n;
 237
 238         n = (mtrr_seg->end - mtrr_seg->start) >> mtrr_seg->range_shift;
 239         return mtrr_seg->range_start + n - 1;
 240 }
 241
 242 static bool fixed_msr_to_range(u32 msr, u64 *start, u64 *end)
 243 {
 244         int seg, unit;
 245
 246         if (!fixed_msr_to_seg_unit(msr, &seg, &unit))
 247                 return false;
 248
 249         fixed_mtrr_seg_unit_range(seg, unit, start, end);
 250         return true;
 251 }
 252
 253 static int fixed_msr_to_range_index(u32 msr)
 254 {
 255         int seg, unit;
 256
 257         if (!fixed_msr_to_seg_unit(msr, &seg, &unit))
 258                 return -1;
 259
 260         return fixed_mtrr_seg_unit_range_index(seg, unit);
 261 }
 262
 263 static int fixed_mtrr_addr_to_seg(u64 addr)
 264 {
 265         struct fixed_mtrr_segment *mtrr_seg;
 266         int seg, seg_num = ARRAY_SIZE(fixed_seg_table);
 267
 268         for (seg = 0; seg < seg_num; seg++) {
 269                 mtrr_seg = &fixed_seg_table[seg];
 270                 if (mtrr_seg->start >= addr && addr < mtrr_seg->end)
 271                         return seg;
 272         }
 273
 274         return -1;
 275 }
 276
 277 static int fixed_mtrr_addr_seg_to_range_index(u64 addr, int seg)
 278 {
 279         struct fixed_mtrr_segment *mtrr_seg;
 280         int index;
 281
 282         mtrr_seg = &fixed_seg_table[seg];
 283         index = mtrr_seg->range_start;
 284         index += (addr - mtrr_seg->start) >> mtrr_seg->range_shift;
 285         return index;
 286 }
 287
 288 static u64 fixed_mtrr_range_end_addr(int seg, int index)
 289 {
 290         struct fixed_mtrr_segment *mtrr_seg = &fixed_seg_table[seg];
 291         int pos = index - mtrr_seg->range_start;
 292
 293         return mtrr_seg->start + ((pos + 1) << mtrr_seg->range_shift);
 294 }
 295
 296 static void var_mtrr_range(struct kvm_mtrr_range *range, u64 *start, u64 *end)
 297 {
 298         u64 mask;
 299
 300         *start = range->base & PAGE_MASK;
 301
 302         mask = range->mask & PAGE_MASK;
 303         mask |= ~0ULL << boot_cpu_data.x86_phys_bits;
 304
 305         /* This cannot overflow because writing to the reserved bits of
 306          * variable MTRRs causes a #GP.
 307          */
 308         *end = (*start | ~mask) + 1;
 309 }
 310
 311 static void update_mtrr(struct kvm_vcpu *vcpu, u32 msr)
 312 {
 313         struct kvm_mtrr *mtrr_state = &vcpu->arch.mtrr_state;
 314         gfn_t start, end;
 315         int index;
 316
 317         if (msr == MSR_IA32_CR_PAT || !tdp_enabled ||
 318               !kvm_arch_has_noncoherent_dma(vcpu->kvm))
 319                 return;
 320
 321         if (!mtrr_is_enabled(mtrr_state) && msr != MSR_MTRRdefType)
 322                 return;
 323
 324         /* fixed MTRRs. */
 325         if (fixed_msr_to_range(msr, &start, &end)) {
 326                 if (!fixed_mtrr_is_enabled(mtrr_state))
 327                         return;
 328         } else if (msr == MSR_MTRRdefType) {
 329                 start = 0x0;
 330                 end = ~0ULL;
 331         } else {
 332                 /* variable range MTRRs. */
 333                 index = (msr - 0x200) / 2;
 334                 var_mtrr_range(&mtrr_state->var_ranges[index], &start, &end);
 335         }
 336
 337         kvm_zap_gfn_range(vcpu->kvm, gpa_to_gfn(start), gpa_to_gfn(end));
 338 }
 339
 340 static bool var_mtrr_range_is_valid(struct kvm_mtrr_range *range)
 341 {
 342         return (range->mask & (1 << 11)) != 0;
 343 }
 344
 345 static void set_var_mtrr_msr(struct kvm_vcpu *vcpu, u32 msr, u64 data)
 346 {
 347         struct kvm_mtrr *mtrr_state = &vcpu->arch.mtrr_state;
 348         struct kvm_mtrr_range *tmp, *cur;
 349         int index, is_mtrr_mask;
 350
 351         index = (msr - 0x200) / 2;
 352         is_mtrr_mask = msr - 0x200 - 2 * index;
 353         cur = &mtrr_state->var_ranges[index];
 354
 355         /* remove the entry if it's in the list. */
 356         if (var_mtrr_range_is_valid(cur))
 357                 list_del(&mtrr_state->var_ranges[index].node);
 358
 359         if (!is_mtrr_mask)
 360                 cur->base = data;
 361         else
 362                 cur->mask = data;
 363
 364         /* add it to the list if it's enabled. */
 365         if (var_mtrr_range_is_valid(cur)) {
 366                 list_for_each_entry(tmp, &mtrr_state->head, node)
 367                         if (cur->base >= tmp->base)
 368                                 break;
 369                 list_add_tail(&cur->node, &tmp->node);
 370         }
 371 }
 372
 373 int kvm_mtrr_set_msr(struct kvm_vcpu *vcpu, u32 msr, u64 data)
 374 {
 375         int index;
 376
 377         if (!kvm_mtrr_valid(vcpu, msr, data))
 378                 return 1;
 379
 380         index = fixed_msr_to_range_index(msr);
 381         if (index >= 0)
 382                 *(u64 *)&vcpu->arch.mtrr_state.fixed_ranges[index] = data;
 383         else if (msr == MSR_MTRRdefType)
 384                 vcpu->arch.mtrr_state.deftype = data;
 385         else if (msr == MSR_IA32_CR_PAT)
 386                 vcpu->arch.pat = data;
 387         else
 388                 set_var_mtrr_msr(vcpu, msr, data);
 389
 390         update_mtrr(vcpu, msr);
 391         return 0;
 392 }
 393
 394 int kvm_mtrr_get_msr(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata)
 395 {
 396         int index;
 397
 398         /* MSR_MTRRcap is a readonly MSR. */
 399         if (msr == MSR_MTRRcap) {
 400                 /*
 401                  * SMRR = 0
 402                  * WC = 1
 403                  * FIX = 1
 404                  * VCNT = KVM_NR_VAR_MTRR
 405                  */
 406                 *pdata = 0x500 | KVM_NR_VAR_MTRR;
 407                 return 0;
 408         }
 409
 410         if (!msr_mtrr_valid(msr))
 411                 return 1;
 412
 413         index = fixed_msr_to_range_index(msr);
 414         if (index >= 0)
 415                 *pdata = *(u64 *)&vcpu->arch.mtrr_state.fixed_ranges[index];
 416         else if (msr == MSR_MTRRdefType)
 417                 *pdata = vcpu->arch.mtrr_state.deftype;
 418         else if (msr == MSR_IA32_CR_PAT)
 419                 *pdata = vcpu->arch.pat;
 420         else {  /* Variable MTRRs */
 421                 int is_mtrr_mask;
 422
 423                 index = (msr - 0x200) / 2;
 424                 is_mtrr_mask = msr - 0x200 - 2 * index;
 425                 if (!is_mtrr_mask)
 426                         *pdata = vcpu->arch.mtrr_state.var_ranges[index].base;
 427                 else
 428                         *pdata = vcpu->arch.mtrr_state.var_ranges[index].mask;
 429         }
 430
 431         return 0;
 432 }
 433
 434 void kvm_vcpu_mtrr_init(struct kvm_vcpu *vcpu)
 435 {
 436         INIT_LIST_HEAD(&vcpu->arch.mtrr_state.head);
 437 }
 438
 439 struct mtrr_iter {
 440         /* input fields. */
 441         struct kvm_mtrr *mtrr_state;
 442         u64 start;
 443         u64 end;
 444
 445         /* output fields. */
 446         int mem_type;
 447         /* mtrr is completely disabled? */
 448         bool mtrr_disabled;
 449         /* [start, end) is not fully covered in MTRRs? */
 450         bool partial_map;
 451
 452         /* private fields. */
 453         union {
 454                 /* used for fixed MTRRs. */
 455                 struct {
 456                         int index;
 457                         int seg;
 458                 };
 459
 460                 /* used for var MTRRs. */
 461                 struct {
 462                         struct kvm_mtrr_range *range;
 463                         /* max address has been covered in var MTRRs. */
 464                         u64 start_max;
 465                 };
 466         };
 467
 468         bool fixed;
 469 };
 470
 471 static bool mtrr_lookup_fixed_start(struct mtrr_iter *iter)
 472 {
 473         int seg, index;
 474
 475         if (!fixed_mtrr_is_enabled(iter->mtrr_state))
 476                 return false;
 477
 478         seg = fixed_mtrr_addr_to_seg(iter->start);
 479         if (seg < 0)
 480                 return false;
 481
 482         iter->fixed = true;
 483         index = fixed_mtrr_addr_seg_to_range_index(iter->start, seg);
 484         iter->index = index;
 485         iter->seg = seg;
 486         return true;
 487 }
 488
 489 static bool match_var_range(struct mtrr_iter *iter,
 490                             struct kvm_mtrr_range *range)
 491 {
 492         u64 start, end;
 493
 494         var_mtrr_range(range, &start, &end);
 495         if (!(start >= iter->end || end <= iter->start)) {
 496                 iter->range = range;
 497
 498                 /*
 499                  * the function is called when we do kvm_mtrr.head walking.
 500                  * Range has the minimum base address which interleaves
 501                  * [looker->start_max, looker->end).
 502                  */
 503                 iter->partial_map |= iter->start_max < start;
 504
 505                 /* update the max address has been covered. */
 506                 iter->start_max = max(iter->start_max, end);
 507                 return true;
 508         }
 509
 510         return false;
 511 }
 512
 513 static void __mtrr_lookup_var_next(struct mtrr_iter *iter)
 514 {
 515         struct kvm_mtrr *mtrr_state = iter->mtrr_state;
 516
 517         list_for_each_entry_continue(iter->range, &mtrr_state->head, node)
 518                 if (match_var_range(iter, iter->range))
 519                         return;
 520
 521         iter->range = NULL;
 522         iter->partial_map |= iter->start_max < iter->end;
 523 }
 524
 525 static void mtrr_lookup_var_start(struct mtrr_iter *iter)
 526 {
 527         struct kvm_mtrr *mtrr_state = iter->mtrr_state;
 528
 529         iter->fixed = false;
 530         iter->start_max = iter->start;
 531         iter->range = list_prepare_entry(iter->range, &mtrr_state->head, node);
 532
 533         __mtrr_lookup_var_next(iter);
 534 }
 535
 536 static void mtrr_lookup_fixed_next(struct mtrr_iter *iter)
 537 {
 538         /* terminate the lookup. */
 539         if (fixed_mtrr_range_end_addr(iter->seg, iter->index) >= iter->end) {
 540                 iter->fixed = false;
 541                 iter->range = NULL;
 542                 return;
 543         }
 544
 545         iter->index++;
 546
 547         /* have looked up for all fixed MTRRs. */
 548         if (iter->index >= ARRAY_SIZE(iter->mtrr_state->fixed_ranges))
 549                 return mtrr_lookup_var_start(iter);
 550
 551         /* switch to next segment. */
 552         if (iter->index > fixed_mtrr_seg_end_range_index(iter->seg))
 553                 iter->seg++;
 554 }
 555
 556 static void mtrr_lookup_var_next(struct mtrr_iter *iter)
 557 {
 558         __mtrr_lookup_var_next(iter);
 559 }
 560
 561 static void mtrr_lookup_start(struct mtrr_iter *iter)
 562 {
 563         if (!mtrr_is_enabled(iter->mtrr_state)) {
 564                 iter->mtrr_disabled = true;
 565                 return;
 566         }
 567
 568         if (!mtrr_lookup_fixed_start(iter))
 569                 mtrr_lookup_var_start(iter);
 570 }
 571
 572 static void mtrr_lookup_init(struct mtrr_iter *iter,
 573                              struct kvm_mtrr *mtrr_state, u64 start, u64 end)
 574 {
 575         iter->mtrr_state = mtrr_state;
 576         iter->start = start;
 577         iter->end = end;
 578         iter->mtrr_disabled = false;
 579         iter->partial_map = false;
 580         iter->fixed = false;
 581         iter->range = NULL;
 582
 583         mtrr_lookup_start(iter);
 584 }
 585
 586 static bool mtrr_lookup_okay(struct mtrr_iter *iter)
 587 {
 588         if (iter->fixed) {
 589                 iter->mem_type = iter->mtrr_state->fixed_ranges[iter->index];
 590                 return true;
 591         }
 592
 593         if (iter->range) {
 594                 iter->mem_type = iter->range->base & 0xff;
 595                 return true;
 596         }
 597
 598         return false;
 599 }
 600
 601 static void mtrr_lookup_next(struct mtrr_iter *iter)
 602 {
 603         if (iter->fixed)
 604                 mtrr_lookup_fixed_next(iter);
 605         else
 606                 mtrr_lookup_var_next(iter);
 607 }
 608
 609 #define mtrr_for_each_mem_type(_iter_, _mtrr_, _gpa_start_, _gpa_end_) \
 610         for (mtrr_lookup_init(_iter_, _mtrr_, _gpa_start_, _gpa_end_); \
 611              mtrr_lookup_okay(_iter_); mtrr_lookup_next(_iter_))
 612
 613 u8 kvm_mtrr_get_guest_memory_type(struct kvm_vcpu *vcpu, gfn_t gfn)
 614 {
 615         struct kvm_mtrr *mtrr_state = &vcpu->arch.mtrr_state;
 616         struct mtrr_iter iter;
 617         u64 start, end;
 618         int type = -1;
 619         const int wt_wb_mask = (1 << MTRR_TYPE_WRBACK)
 620                                | (1 << MTRR_TYPE_WRTHROUGH);
 621
 622         start = gfn_to_gpa(gfn);
 623         end = start + PAGE_SIZE;
 624
 625         mtrr_for_each_mem_type(&iter, mtrr_state, start, end) {
 626                 int curr_type = iter.mem_type;
 627
 628                 /*
 629                  * Please refer to Intel SDM Volume 3: 11.11.4.1 MTRR
 630                  * Precedences.
 631                  */
 632
 633                 if (type == -1) {
 634                         type = curr_type;
 635                         continue;
 636                 }
 637
 638                 /*
 639                  * If two or more variable memory ranges match and the
 640                  * memory types are identical, then that memory type is
 641                  * used.
 642                  */
 643                 if (type == curr_type)
 644                         continue;
 645
 646                 /*
 647                  * If two or more variable memory ranges match and one of
 648                  * the memory types is UC, the UC memory type used.
 649                  */
 650                 if (curr_type == MTRR_TYPE_UNCACHABLE)
 651                         return MTRR_TYPE_UNCACHABLE;
 652
 653                 /*
 654                  * If two or more variable memory ranges match and the
 655                  * memory types are WT and WB, the WT memory type is used.
 656                  */
 657                 if (((1 << type) & wt_wb_mask) &&
 658                       ((1 << curr_type) & wt_wb_mask)) {
 659                         type = MTRR_TYPE_WRTHROUGH;
 660                         continue;
 661                 }
 662
 663                 /*
 664                  * For overlaps not defined by the above rules, processor
 665                  * behavior is undefined.
 666                  */
 667
 668                 /* We use WB for this undefined behavior. :( */
 669                 return MTRR_TYPE_WRBACK;
 670         }
 671
 672         if (iter.mtrr_disabled)
 673                 return mtrr_disabled_type();
 674
 675         /*
 676          * We just check one page, partially covered by MTRRs is
 677          * impossible.
 678          */
 679         WARN_ON(iter.partial_map);
 680
 681         /* not contained in any MTRRs. */
 682         if (type == -1)
 683                 return mtrr_default_type(mtrr_state);
 684
 685         return type;
 686 }
 687 EXPORT_SYMBOL_GPL(kvm_mtrr_get_guest_memory_type);
 688
 689 bool kvm_mtrr_check_gfn_range_consistency(struct kvm_vcpu *vcpu, gfn_t gfn,
 690                                           int page_num)
 691 {
 692         struct kvm_mtrr *mtrr_state = &vcpu->arch.mtrr_state;
 693         struct mtrr_iter iter;
 694         u64 start, end;
 695         int type = -1;
 696
 697         start = gfn_to_gpa(gfn);
 698         end = gfn_to_gpa(gfn + page_num);
 699         mtrr_for_each_mem_type(&iter, mtrr_state, start, end) {
 700                 if (type == -1) {
 701                         type = iter.mem_type;
 702                         continue;
 703                 }
 704
 705                 if (type != iter.mem_type)
 706                         return false;
 707         }
 708
 709         if (iter.mtrr_disabled)
 710                 return true;
 711
 712         if (!iter.partial_map)
 713                 return true;
 714
 715         if (type == -1)
 716                 return true;
 717
 718         return type == mtrr_default_type(mtrr_state);
 719 }