1. Если вы только начинаете программировать на ассемблере и не знаете с чего начать, тогда попробуйте среду разработки ASM Visual IDE
    (c) на правах рекламы
    Скрыть объявление

Виртуализация для самых маленьких #3: готовим структуры, заполняем EPT

Дата публикации 21 июн 2020 | Редактировалось 22 июн 2020
В прошлой части мы получили теоретическую базу по принципам настройки гипервизора и EPT.
Применим их на практике.

В первой части мы написали шаблон драйвера и заготовку для виртуализации всех процессоров - функцию VirtualizeAllProcessors.
Код виртуализации будет необходимо выполнить на всех процессорах и это легко сделать через генерацию межпроцессорного прерывания функцией KeIpiGenericCall.
Каждый логический процессор выполнит код, переводящий его в режим виртуализации, и продолжит свою работу уже в виртуализованном окружении, незаметно для системы.

Так как обработчики IPI выполняются на высоком IRQL (IPI_LEVEL), нам необходимо подготовить все данные, которые могут понадобиться коду виртуализации.
В первую очередь, выделить память под таблицы EPT, под структуры VMCS, а также, под стек для VMM.

На стеке для VMM остановимся подробнее.
Когда процессор переходит из гостя в VMM, из VMCS в процессор загружаются значения RIP (адрес нашей функции-обработчика) и RSP (стек, с которым будет работать VMM), заданные при настройке VMCS на этапе инициализации гипервизора.
Память под стек нам необходимо выделить самостоятельно и освободим мы её лишь после полной остановки гипервизора.

Так как в VMCS хранятся физические адреса дополнительных структур, а в процессор загружается физический адрес VMCS, память под них должна быть физически непрерывной.
Этого можно добиться, выделяя память функцией MmAllocateContiguousMemorySpecifyCache.

Для начала, в Hypervisor.cpp напишем необходимые обёртки над функциями для работы с памятью:
Код (C):
  1.  
  2. namespace VirtualMemory
  3. {
  4.     constexpr ULONG PoolTag = 'LOOP';
  5.  
  6.     static PVOID AllocArray(SIZE_T SizeOfElement, SIZE_T ElementsCount)
  7.     {
  8.         auto BufSize = SizeOfElement * ElementsCount;
  9.         PVOID Buf = ExAllocatePoolWithTag(NonPagedPool, BufSize, PoolTag);
  10.         if (Buf)
  11.         {
  12.             RtlSecureZeroMemory(Buf, BufSize);
  13.         }
  14.         return Buf;
  15.     }
  16.  
  17.     template <typename T>
  18.     inline T* AllocArray(SIZE_T ElementsCount)
  19.     {
  20.         return reinterpret_cast<T*>(AllocArray(sizeof(T), ElementsCount));
  21.     }
  22.  
  23.     _IRQL_requires_max_(DISPATCH_LEVEL)
  24.     static VOID FreePoolMemory(__drv_freesMem(Mem) PVOID Address)
  25.     {
  26.         ExFreePoolWithTag(Address, PoolTag);
  27.     }
  28. }
  29.  
  30. namespace PhysicalMemory
  31. {
  32.     _IRQL_requires_max_(DISPATCH_LEVEL)
  33.     static PVOID AllocPhysicalMemorySpecifyCache(
  34.         PVOID64 LowestAcceptableAddress,
  35.         PVOID64 HighestAcceptableAddress,
  36.         PVOID64 BoundaryAddressMultiple,
  37.         SIZE_T Size,
  38.         MEMORY_CACHING_TYPE CachingType
  39.     ) {
  40.         return MmAllocateContiguousMemorySpecifyCache(
  41.             Size,
  42.             *reinterpret_cast<PHYSICAL_ADDRESS*>(&LowestAcceptableAddress),
  43.             *reinterpret_cast<PHYSICAL_ADDRESS*>(&HighestAcceptableAddress),
  44.             *reinterpret_cast<PHYSICAL_ADDRESS*>(&BoundaryAddressMultiple),
  45.             CachingType
  46.         );
  47.     }
  48.  
  49.     _IRQL_requires_max_(DISPATCH_LEVEL)
  50.     static VOID FreePhysicalMemory(PVOID BaseVirtualAddress)
  51.     {
  52.         MmFreeContiguousMemory(BaseVirtualAddress);
  53.     }
  54.  
  55.     static PVOID64 GetPhysicalAddress(const void* VirtualAddress)
  56.     {
  57.         return reinterpret_cast<PVOID64>(MmGetPhysicalAddress(const_cast<void*>(VirtualAddress)).QuadPart);
  58.     }
  59. }
  60.  
  61. namespace Supplementation
  62. {
  63.     _IRQL_requires_max_(DISPATCH_LEVEL)
  64.     static PVOID AllocPhys(SIZE_T Size, MEMORY_CACHING_TYPE CachingType = MmCached, ULONG MaxPhysBits = 0)
  65.     {
  66.         PVOID64 HighestAcceptableAddress = MaxPhysBits
  67.             ? reinterpret_cast<PVOID64>((1ULL << MaxPhysBits) - 1)
  68.             : reinterpret_cast<PVOID64>((1ULL << 48) - 1);
  69.  
  70.         PVOID Memory = PhysicalMemory::AllocPhysicalMemorySpecifyCache(
  71.             0,
  72.             HighestAcceptableAddress,
  73.             0,
  74.             Size,
  75.             CachingType
  76.         );
  77.  
  78.         if (Memory) RtlSecureZeroMemory(Memory, Size);
  79.         return Memory;
  80.     }
  81.  
  82.     _IRQL_requires_max_(DISPATCH_LEVEL)
  83.     static VOID FreePhys(PVOID Memory)
  84.     {
  85.         PhysicalMemory::FreePhysicalMemory(Memory);
  86.     }
  87. }
  88.  
Теперь подготовим структуры с данными, необходимыми для настройки и работы гипервизора.

Каждому логическому процессору заведём структуру со своими экземплярами VMCS, EPT и прочих структур.
Назовём эту структуру "PRIVATE_VM_DATA" и память под неё выделим динамически для каждого логического процессора.
Также нам понадобится хранилище данных, общих для всех виртуальных процессоров.
Эту общую структуру назовём "SHARED_VM_DATA", она будет в единственном экземпляре и мы поместим её в глобальную область видимости.

Код (C):
  1.  
  2. #include "VMX.h"
  3.  
  4. ...
  5.  
  6. namespace VMX
  7. {
  8.     using namespace Intel;
  9.     ...
  10.  
  11.     struct SHARED_VM_DATA;
  12.  
  13.     // Unique for each processor:
  14.     struct PRIVATE_VM_DATA
  15.     {
  16.         union
  17.         {
  18.             DECLSPEC_ALIGN(PAGE_SIZE) unsigned char VmmStack[KERNEL_STACK_SIZE];
  19.             struct
  20.             {
  21.                 struct INITIAL_VMM_STACK_LAYOUT
  22.                 {
  23.                     PVOID VmcsPa;
  24.                     SHARED_VM_DATA* Shared;
  25.                     PRIVATE_VM_DATA* Private;
  26.                 };
  27.                 unsigned char FreeSpace[KERNEL_STACK_SIZE - sizeof(INITIAL_VMM_STACK_LAYOUT)];
  28.                 INITIAL_VMM_STACK_LAYOUT InitialStack;
  29.             } Layout;
  30.         } VmmStack;
  31.         DECLSPEC_ALIGN(PAGE_SIZE) VMCS Vmxon; // VMXON structure is the same as VMCS with the same size
  32.         DECLSPEC_ALIGN(PAGE_SIZE) VMCS Vmcs;
  33.         DECLSPEC_ALIGN(PAGE_SIZE) MSR_BITMAP MsrBitmap;
  34.     };
  35.  
  36.     struct SHARED_VM_DATA
  37.     {
  38.         PRIVATE_VM_DATA* Processors; // Array: PRIVATE_VM_DATA Processors[ProcessorsCount]
  39.         unsigned int ProcessorsCount;
  40.     };
  41.  
  42.     static SHARED_VM_DATA g_Shared = {};
  43.  
  44.     ...
  45. }
  46.  
Рассмотрим подробнее PRIVATE_VM_DATA.
В этой большой структуре мы будем хранить данные, необходимые виртуальному процессору для работы:
- Стек VMM, который будет использовать наш обработчик при наступлении #VMEXIT.
- Регион VMXON, необходимый для перехода в режим "VMX root operation" - пустой регион с размером, идентичным VMCS, физический адрес которого передаётся в инструкцию vmxon (в документации Intel не описывает деталей его предназначения и, в отличие от VMCS, этот регион не требует особой настройки, кроме одного поля с ревизией VMCS).
- VMCS, описывающая состояние виртуализованной среды и VMM.

В стек мы положим адреса SHARED_VM_DATA и самой PRIVATE_VM_DATA для текущего логического процессора, а также, физический адрес текущей VMCS (который теоретически может нам понадобиться), чтобы иметь к ним быстрый и удобный доступ в VMM.

Следующий шаг - объявление структур EPT. Мы покроем всё физическое адресное пространство, к которому может обратиться процессор, описав в EPT 512 Гб физической памяти.
Для экономии памяти под таблицы и для ускорения трансляции мы будем описывать 512 Гб большими двухмегабайтными страницами.
Для этого нам понадобится:
- Одна запись PML4E, описывающая все 512 Гб через 512 записей PDPTE
- 512 записей PDPTE, каждая из которых описывает 1 Гб физического АП через 512 записей PDE в каждой
- 512 * 512 записей PDE, каждая из которых описывает 2 Мб физического АП (512 PDE в каждом PDPTE, которых самих 512)
- 512 записей PTE, описывающие первые два мегабайта физической памяти, т.к. первый мегабайт описывается фиксированными MTRR и нам нужно более тонко настроить кэширование для этого региона, избежав конфликтов типов кэшей, которые практически наверняка будут при описании этого региона одной большой страницей (и тогда пришлось бы задавать всей странице тип Uncacheable).

Итоговые таблицы опишем в одной структуре:
Код (C):
  1.  
  2. namespace VMX
  3. {
  4.     ...
  5.  
  6.     struct EPT_TABLES
  7.     {
  8.         DECLSPEC_ALIGN(PAGE_SIZE) EPT_PML4E Pml4e;
  9.         DECLSPEC_ALIGN(PAGE_SIZE) EPT_PDPTE Pdpte[512];
  10.         DECLSPEC_ALIGN(PAGE_SIZE) EPT_PDE Pde[512][512];
  11.         DECLSPEC_ALIGN(PAGE_SIZE) EPT_PTE PteForFirstLargePage[2 * 1048576 / 4096]; // 512 entries for the first 2Mb
  12.     };
  13. }
  14.  
Размер этой таблицы чуть превышает 2 Мб.

Пытливый ум спросит: зачем описывать все 512 гигабайт, если установленной физической RAM намного меньше.
Действительно, можно определить количество установленной оперативной памяти и создавать таблицы только для неё, однако другие физические устройства могут отображать своё адресное пространство на физическое адресное пространство процессора (MMIO).
Если процессор обратится к такой памяти, которая не описана в EPT, наш VMM получит исключение "EPT violation" (Volume 3, Chapter 28.2.3.2) и нам придётся динамически создавать для этого региона описание в EPT.
Это сильно усложняет разработку, поэтому для простоты мы используем фиксированный EPT, описывающий все 512 гигабайт ценой большего размера таблиц.

Так как EPT для каждого логического процессора своя, добавим её в PRIVATE_VM_DATA:
Код (C):
  1.  
  2. namespace VMX
  3. {
  4.     ...
  5.     struct PRIVATE_VM_DATA
  6.     {
  7.         union
  8.         {
  9.             ...
  10.         } VmmStack;
  11.  
  12.         DECLSPEC_ALIGN(PAGE_SIZE) VMCS Vmxon; // VMXON structure is the same as VMCS with the same size
  13.         DECLSPEC_ALIGN(PAGE_SIZE) VMCS Vmcs;
  14.         DECLSPEC_ALIGN(PAGE_SIZE) EPT_TABLES Ept;
  15.     };
  16. }
  17.  
Как было описано в прошлой статье, тип кэширования страницы задаётся явно на последнем уровне трансляции в EPT и этот тип необходимо определить с помощью регистров MTRR.

Опишем всё, связанное с MTRR, в одной большой структуре (Fixed- и Variable-регистры и значения MSR, необходимые для их обработки):
Код (C):
  1.  
  2. namespace VMX
  3. {
  4.     ...
  5.  
  6.     struct MTRR_INFO
  7.     {
  8.         UINT64 MaxPhysAddrBits;
  9.         UINT64 PhysAddrMask;
  10.  
  11.         IA32_VMX_EPT_VPID_CAP EptVpidCap;
  12.         IA32_MTRRCAP MtrrCap;
  13.         IA32_MTRR_DEF_TYPE MtrrDefType;
  14.  
  15.         // For the first 1 megabyte of the physical address space:
  16.         union
  17.         {
  18.             MTRR_FIXED_GENERIC Generic[11];
  19.             struct {
  20.                 // 512-Kbyte range:
  21.                 IA32_MTRR_FIX64K RangeFrom00000To7FFFF;
  22.  
  23.                 // Two 128-Kbyte ranges:
  24.                 IA32_MTRR_FIX16K RangeFrom80000To9FFFF;
  25.                 IA32_MTRR_FIX16K RangeFromA0000ToBFFFF;
  26.  
  27.                 // Eight 32-Kbyte ranges:
  28.                 IA32_MTRR_FIX4K RangeFromC0000ToC7FFF;
  29.                 IA32_MTRR_FIX4K RangeFromC8000ToCFFFF;
  30.                 IA32_MTRR_FIX4K RangeFromD0000ToD7FFF;
  31.                 IA32_MTRR_FIX4K RangeFromD8000ToDFFFF;
  32.                 IA32_MTRR_FIX4K RangeFromE0000ToE7FFF;
  33.                 IA32_MTRR_FIX4K RangeFromE8000ToEFFFF;
  34.                 IA32_MTRR_FIX4K RangeFromF0000ToF7FFF;
  35.                 IA32_MTRR_FIX4K RangeFromF8000ToFFFFF;
  36.             } Ranges;
  37.         } Fixed;
  38.  
  39.         // For the memory above the first megabyte of the physical address space:
  40.         struct
  41.         {
  42.             IA32_MTRR_PHYSBASE PhysBase;
  43.             IA32_MTRR_PHYSMASK PhysMask;
  44.         } Variable[10];
  45.  
  46.         bool IsSupported;
  47.     };
  48.  
  49.     ...
  50. }
  51.  
Имея все вышеописанные структуры, можем начинать инициализацию.
Начнём с инициализации MTRR:
Код (C):
  1.  
  2. namespace VMX
  3. {
  4.     ...
  5.  
  6.     // E.g.: MaskLow<char>(5) -> 0b00011111:
  7.     template <typename T>
  8.     constexpr T MaskLow(unsigned char SignificantBits)
  9.     {
  10.         return static_cast<T>((1ULL << SignificantBits) - 1);
  11.     }
  12.  
  13.     // E.g.: MaskHigh<char>(3) -> 0b11100000:
  14.     template <typename T>
  15.     constexpr T MaskHigh(unsigned char SignificantBits)
  16.     {
  17.         return MaskLow<T>(SignificantBits) << ((sizeof(T) * 8) - SignificantBits);
  18.     }
  19.  
  20.     static void InitMtrr(__out MTRR_INFO* MtrrInfo)
  21.     {
  22.         memset(MtrrInfo, 0, sizeof(*MtrrInfo));
  23.  
  24.         CPUID::FEATURE_INFORMATION Features = {};
  25.         __cpuid(Features.Regs.Raw, CPUID::Intel::CPUID_FEATURE_INFORMATION);
  26.         MtrrInfo->IsSupported = Features.Intel.MTRR;
  27.         if (!MtrrInfo->IsSupported) return;
  28.  
  29.         CPUID::Intel::VIRTUAL_AND_PHYSICAL_ADDRESS_SIZES MaxAddrSizes = {};
  30.         __cpuid(MaxAddrSizes.Regs.Raw, CPUID::Intel::CPUID_VIRTUAL_AND_PHYSICAL_ADDRESS_SIZES);
  31.         MtrrInfo->MaxPhysAddrBits = MaxAddrSizes.Bitmap.PhysicalAddressBits;
  32.         MtrrInfo->PhysAddrMask = ~MaskLow<unsigned long long>(static_cast<unsigned char>(MtrrInfo->MaxPhysAddrBits));
  33.  
  34.         MtrrInfo->EptVpidCap.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_VMX_EPT_VPID_CAP));
  35.         MtrrInfo->MtrrCap.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRRCAP));
  36.         MtrrInfo->MtrrDefType.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_DEF_TYPE));
  37.  
  38.         if (MtrrInfo->MtrrCap.Bitmap.FIX && MtrrInfo->MtrrDefType.Bitmap.FE)
  39.         {
  40.             // 512-Kbyte range:
  41.             MtrrInfo->Fixed.Ranges.RangeFrom00000To7FFFF.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_FIX64K_00000));
  42.  
  43.             // Two 128-Kbyte ranges:
  44.             MtrrInfo->Fixed.Ranges.RangeFrom80000To9FFFF.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_FIX16K_80000));
  45.             MtrrInfo->Fixed.Ranges.RangeFromA0000ToBFFFF.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_FIX16K_A0000));
  46.  
  47.             // Eight 32-Kbyte ranges:
  48.             MtrrInfo->Fixed.Ranges.RangeFromC0000ToC7FFF.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_FIX4K_C0000));
  49.             MtrrInfo->Fixed.Ranges.RangeFromC8000ToCFFFF.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_FIX4K_C8000));
  50.             MtrrInfo->Fixed.Ranges.RangeFromD0000ToD7FFF.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_FIX4K_D0000));
  51.             MtrrInfo->Fixed.Ranges.RangeFromD8000ToDFFFF.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_FIX4K_D8000));
  52.             MtrrInfo->Fixed.Ranges.RangeFromE0000ToE7FFF.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_FIX4K_E0000));
  53.             MtrrInfo->Fixed.Ranges.RangeFromE8000ToEFFFF.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_FIX4K_E8000));
  54.             MtrrInfo->Fixed.Ranges.RangeFromF0000ToF7FFF.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_FIX4K_F0000));
  55.             MtrrInfo->Fixed.Ranges.RangeFromF8000ToFFFFF.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_FIX4K_F8000));
  56.         }
  57.  
  58.         for (unsigned i = 0; i < MtrrInfo->MtrrCap.Bitmap.VCNT; ++i)
  59.         {
  60.             if (i == ARRAYSIZE(MtrrInfo->Variable)) break;
  61.  
  62.             MtrrInfo->Variable[i].PhysBase.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_PHYSBASE0) + i * 2);
  63.             MtrrInfo->Variable[i].PhysMask.Value = __readmsr(static_cast<unsigned long>(INTEL_MSR::IA32_MTRR_PHYSMASK0) + i * 2);
  64.         }
  65.     }
  66. }
  67.  
Разберём пошагово:
1. Проверили, поддерживает ли процессор MTRR (CPUID_FEATURE_INFORMATION::MTRR).
2. Получили максимальное поддерживаемое количество бит в физическом адресе.
3. Прочитали MSR, необходимые для дальнейшей интерпретации MTRR.
4. Прочитали все Fixed-MTRR.
5. Прочитали все существующие Variable-MTRR, количество которых берём из IA32_MTRRCAP.

Для заполнения типов кэшей в EPT нам понадобятся вспомогательные функции, вычисляющие тип заданной страницы памяти на основе прочитанных MTRR.
Принцип простой: для каждой страницы перебираем все MTRR и "смешиваем" типы тех MTRR, которые описывают регионы, входящие в нашу страницу.

Для начала напишем процедуру, "смешивающую" два типа кэша по специальным правилам, описанным в прошлой главе (также см. Volume 3, Chapter 11.11.4.1 MTRR Precedences):
1. Если хотя бы у одной страницы, входящей в регион, тип Uncacheable, весь регион становится Uncacheable.
2. Если в регионе есть только страницы с типами WriteBack и хотя бы один WriteThrough, весь регион помечается как WriteThrough.
3. Все остальные случаи - конфликт типов. В этом случае весь регион должен быть помечен как Uncacheable.
Код (C):
  1.  
  2. namespace VMX
  3. {
  4.    ...
  5.  
  6.     static bool MixMtrrTypes(MTRR_MEMORY_TYPE Type1, MTRR_MEMORY_TYPE Type2, __out MTRR_MEMORY_TYPE& Mixed)
  7.     {
  8.         Mixed = MTRR_MEMORY_TYPE::Uncacheable;
  9.         if (Type1 == MTRR_MEMORY_TYPE::Uncacheable || Type2 == MTRR_MEMORY_TYPE::Uncacheable)
  10.         {
  11.             Mixed = MTRR_MEMORY_TYPE::Uncacheable;
  12.             return true;
  13.         }
  14.  
  15.         if (Type1 == Type2)
  16.         {
  17.             Mixed = Type1;
  18.             return true;
  19.         }
  20.         else
  21.         {
  22.             if ((Type1 == MTRR_MEMORY_TYPE::WriteThrough || Type1 == MTRR_MEMORY_TYPE::WriteBack)
  23.                 && (Type2 == MTRR_MEMORY_TYPE::WriteThrough || Type2 == MTRR_MEMORY_TYPE::WriteBack))
  24.             {
  25.                 Mixed = MTRR_MEMORY_TYPE::WriteThrough;
  26.                 return true;
  27.             }
  28.         }
  29.  
  30.         return false; // Memory types are conflicting, returning Uncacheable
  31.     }
  32.  
  33.    ...
  34. }
  35.  
И напишем большую функцию, которая для заданной страницы заданного размера обойдёт все MTRR, выберет подходящие и "смешает" их типы:
Код (C):
  1.  
  2. namespace VMX
  3. {
  4.     struct MEMORY_RANGE
  5.     {
  6.         unsigned long long First;
  7.         unsigned long long Last;
  8.     };
  9.  
  10.     static bool AreRangesIntersects(const MEMORY_RANGE& Range1, const MEMORY_RANGE& Range2)
  11.     {
  12.         return Range1.First <= Range2.Last && Range1.Last >= Range2.First;
  13.     }
  14.  
  15.     static MTRR_MEMORY_TYPE CalcMemoryTypeByFixedMtrr(
  16.         MTRR_FIXED_GENERIC FixedMtrrGeneric,
  17.         const MEMORY_RANGE& MtrrRange,
  18.         const MEMORY_RANGE& PhysRange
  19.     ) {
  20.         bool Initialized = false;
  21.  
  22.         MTRR_MEMORY_TYPE MemType = MTRR_MEMORY_TYPE::Uncacheable;
  23.         constexpr unsigned long long RangeBitsMask = 0b11111111;
  24.         constexpr unsigned long long RangeBitsCount = 8;
  25.         constexpr unsigned long long RangesCount = (sizeof(FixedMtrrGeneric) * 8) / RangeBitsCount;
  26.         const unsigned long long SubrangeSize = (MtrrRange.Last - MtrrRange.First + 1) / RangeBitsCount;
  27.  
  28.         for (unsigned int i = 0; i < RangesCount; ++i)
  29.         {
  30.             MEMORY_RANGE Subrange;
  31.             Subrange.First = MtrrRange.First + i * SubrangeSize;
  32.             Subrange.Last = Subrange.First + SubrangeSize - 1;
  33.  
  34.             if (AreRangesIntersects(PhysRange, Subrange))
  35.             {
  36.                 MTRR_MEMORY_TYPE SubrangeType = static_cast<MTRR_MEMORY_TYPE>((FixedMtrrGeneric.Value >> (i * RangeBitsCount)) & RangeBitsMask);
  37.                 if (Initialized)
  38.                 {
  39.                     bool MixingStatus = MixMtrrTypes(MemType, SubrangeType, OUT MemType);
  40.                     if (!MixingStatus)
  41.                     {
  42.                         // Cache types are conflicting in overlapped regions, returning Uncacheable:
  43.                         MemType = MTRR_MEMORY_TYPE::Uncacheable;
  44.                     }
  45.                 }
  46.                 else
  47.                 {
  48.                     MemType = SubrangeType;
  49.                     Initialized = true;
  50.                 }
  51.  
  52.                 // If at least one range is Uncacheable - then
  53.                 // all overlapped ranges are Uncacheable:
  54.                 if (MemType == MTRR_MEMORY_TYPE::Uncacheable)
  55.                 {
  56.                     break;
  57.                 }
  58.             }
  59.         }
  60.  
  61.         return MemType;
  62.     }
  63.  
  64.     static const MEMORY_RANGE FixedRanges[] = {
  65.         { 0x00000, 0x7FFFF },
  66.         { 0x80000, 0x9FFFF },
  67.         { 0xA0000, 0xBFFFF },
  68.         { 0xC0000, 0xC7FFF },
  69.         { 0xC8000, 0xCFFFF },
  70.         { 0xD0000, 0xD7FFF },
  71.         { 0xD8000, 0xDFFFF },
  72.         { 0xE0000, 0xE7FFF },
  73.         { 0xE8000, 0xEFFFF },
  74.         { 0xF0000, 0xF7FFF },
  75.         { 0xF8000, 0xFFFFF },
  76.     };
  77.  
  78.     static MTRR_MEMORY_TYPE GetMtrrMemoryType(__in const MTRR_INFO* MtrrInfo, unsigned long long PhysicalAddress, unsigned int PageSize)
  79.     {
  80.         if (!MtrrInfo || !PageSize || !MtrrInfo->MtrrDefType.Bitmap.E)
  81.             return MTRR_MEMORY_TYPE::Uncacheable;
  82.  
  83.         constexpr unsigned long long FIRST_MEGABYTE = 0x100000ULL;
  84.  
  85.         MEMORY_RANGE PhysRange = {};
  86.         PhysRange.First = PhysicalAddress;
  87.         PhysRange.Last = PhysicalAddress + PageSize - 1;
  88.  
  89.         bool IsMemTypeInitialized = false;
  90.  
  91.         // Default type:
  92.         MTRR_MEMORY_TYPE MemType = static_cast<MTRR_MEMORY_TYPE>(MtrrInfo->MtrrDefType.Bitmap.Type);
  93.         if (PhysicalAddress < FIRST_MEGABYTE && MtrrInfo->MtrrCap.Bitmap.FIX && MtrrInfo->MtrrDefType.Bitmap.FE)
  94.         {
  95.             for (unsigned int i = 0; i < ARRAYSIZE(FixedRanges); ++i)
  96.             {
  97.                 MTRR_FIXED_GENERIC MtrrFixedGeneric = {};
  98.                 MtrrFixedGeneric.Value = MtrrInfo->Fixed.Generic[i].Value;
  99.                 if (AreRangesIntersects(PhysRange, FixedRanges[i]))
  100.                 {
  101.                     MTRR_MEMORY_TYPE FixedMemType = CalcMemoryTypeByFixedMtrr(MtrrFixedGeneric, FixedRanges[i], PhysRange);
  102.                     if (FixedMemType == MTRR_MEMORY_TYPE::Uncacheable) return FixedMemType;
  103.  
  104.                     if (IsMemTypeInitialized)
  105.                     {
  106.                         bool IsMixed = MixMtrrTypes(MemType, FixedMemType, OUT MemType);
  107.                         if (!IsMixed)
  108.                         {
  109.                             return MTRR_MEMORY_TYPE::Uncacheable;
  110.                         }
  111.                     }
  112.                     else
  113.                     {
  114.                         IsMemTypeInitialized = true;
  115.                         MemType = FixedMemType;
  116.                     }
  117.                 }
  118.             }
  119.         }
  120.  
  121.         for (unsigned int i = 0; i < MtrrInfo->MtrrCap.Bitmap.VCNT; ++i)
  122.         {
  123.             // If this entry is valid:
  124.             if (!MtrrInfo->Variable[i].PhysMask.Bitmap.V) continue;
  125.  
  126.             unsigned long long MtrrPhysBase = PFN_TO_PAGE(MtrrInfo->Variable[i].PhysBase.Bitmap.PhysBasePfn);
  127.             unsigned long long MtrrPhysMask = PFN_TO_PAGE(MtrrInfo->Variable[i].PhysMask.Bitmap.PhysMaskPfn) | MtrrInfo->PhysAddrMask;
  128.             unsigned long long MaskedMtrrPhysBase = MtrrPhysBase & MtrrPhysMask;
  129.             MTRR_MEMORY_TYPE VarMemType = MTRR_MEMORY_TYPE::Uncacheable;
  130.  
  131.             bool IsVarMemTypeInitialized = false;
  132.  
  133.             for (unsigned long long Page = PhysicalAddress; Page < PhysicalAddress + PageSize; Page += PAGE_SIZE)
  134.             {
  135.                 if ((Page & MtrrPhysMask) == MaskedMtrrPhysBase)
  136.                 {
  137.                     auto PageMemType = static_cast<MTRR_MEMORY_TYPE>(MtrrInfo->Variable[i].PhysBase.Bitmap.Type);
  138.                     if (IsVarMemTypeInitialized)
  139.                     {
  140.                         bool IsMixed = MixMtrrTypes(VarMemType, PageMemType, OUT VarMemType);
  141.                         if (!IsMixed)
  142.                         {
  143.                             return MTRR_MEMORY_TYPE::Uncacheable;
  144.                         }
  145.                     }
  146.                     else
  147.                     {
  148.                         VarMemType = PageMemType;
  149.                         IsVarMemTypeInitialized = true;
  150.                     }
  151.  
  152.                     if (VarMemType == MTRR_MEMORY_TYPE::Uncacheable)
  153.                     {
  154.                         return MTRR_MEMORY_TYPE::Uncacheable;
  155.                     }
  156.                 }
  157.             }
  158.  
  159.             if (IsVarMemTypeInitialized)
  160.             {
  161.                 if (VarMemType == MTRR_MEMORY_TYPE::Uncacheable)
  162.                 {
  163.                     return MTRR_MEMORY_TYPE::Uncacheable;
  164.                 }
  165.  
  166.                 if (IsMemTypeInitialized)
  167.                 {
  168.                     bool IsMixed = MixMtrrTypes(MemType, VarMemType, OUT MemType);
  169.                     if (!IsMixed)
  170.                     {
  171.                         return MTRR_MEMORY_TYPE::Uncacheable;
  172.                     }
  173.                 }
  174.                 else
  175.                 {
  176.                     MemType = VarMemType;
  177.                     IsMemTypeInitialized = true;
  178.                 }
  179.             }
  180.         }
  181.  
  182.         return MemType;
  183.     }
  184. }
  185.  
Так как код большой и неочевидный, он требует пояснений.
В функцию GetMtrrMemoryType передаём заполненные MTRR; адрес страницы, тип которой хотим получить, и её размер.
Если страница попадает в первый мегабайт, сначала получаем её тип из фиксированных MTRR, перебирая их все и вычисляя тип по каждому MTRR функцией CalcMemoryTypeByFixedMtrr.
В эту функцию передаём значение фиксированного MTRR и диапазон, который он описывает.
Т.к. один фиксированный MTRR описывает 8 поддиапазонов, перебираем их все и, если поддиапазон попадает в нашу страницу, возвращаем тип этого поддиапазона.
Если это был первый вычисленный тип - запоминаем его. Если тип был получен ранее из предыдущих MTRR - "смешиваем" текущий тип с предыдущим.
Затем перебираем набор из Variable-MTRR.
Т.к. они оперируют страницами по 4 Кб, разбиваем наш диапазон на страницы по 4 Кб и вычисляем тип для каждой, исходя из соотношения:
PhysBase & PhysMask == PagePhysAddr & PhysMask.
Если это соотношение выполняется - диапазон в MTRR пересекается со 4х-килобайтной страницей из нашего диапазона - и мы учитываем тип из MTRR.
Как и в случае фиксированных MTRR, если тип уже был вычислен раньше - "смешиваем" текущий тип с прошлым значением.

И, наконец, используя GetMtrrMemoryType, напишем функцию, заполняющую EPT:
Код (C):
  1.  
  2. namespace VMX
  3. {
  4.     ...
  5.  
  6.     static void InitializeEptTables(__in const MTRR_INFO* MtrrInfo, __out EPT_TABLES* Ept)
  7.     {
  8.         using namespace PhysicalMemory;
  9.         memset(Ept, 0, sizeof(EPT_TABLES));
  10.  
  11.         PVOID64 PdptePhys = GetPhysicalAddress(Ept->Pdpte);
  12.         Ept->Pml4e.Page2Mb.ReadAccess = TRUE;
  13.         Ept->Pml4e.Page2Mb.WriteAccess = TRUE;
  14.         Ept->Pml4e.Page2Mb.ExecuteAccess = TRUE;
  15.         Ept->Pml4e.Page2Mb.EptPdptePhysicalPfn = PAGE_TO_PFN(reinterpret_cast<UINT64>(PdptePhys));
  16.  
  17.         for (unsigned int i = 0; i < _ARRAYSIZE(Ept->Pdpte); ++i)
  18.         {
  19.             PVOID64 PdePhys = GetPhysicalAddress(Ept->Pde[i]);
  20.             Ept->Pdpte[i].Page2Mb.ReadAccess = TRUE;
  21.             Ept->Pdpte[i].Page2Mb.WriteAccess = TRUE;
  22.             Ept->Pdpte[i].Page2Mb.ExecuteAccess = TRUE;
  23.             Ept->Pdpte[i].Page2Mb.EptPdePhysicalPfn = PAGE_TO_PFN(reinterpret_cast<UINT64>(PdePhys));
  24.  
  25.             for (unsigned int j = 0; j < _ARRAYSIZE(Ept->Pde[i]); ++j)
  26.             {
  27.                 if (i == 0 && j == 0)
  28.                 {
  29.                     PVOID64 PtePhys = GetPhysicalAddress(Ept->PteForFirstLargePage);
  30.  
  31.                     Ept->Pde[i][j].Page4Kb.ReadAccess = TRUE;
  32.                     Ept->Pde[i][j].Page4Kb.WriteAccess = TRUE;
  33.                     Ept->Pde[i][j].Page4Kb.ExecuteAccess = TRUE;
  34.                     Ept->Pde[i][j].Page4Kb.EptPtePhysicalPfn = PAGE_TO_PFN(reinterpret_cast<UINT64>(PtePhys));
  35.  
  36.                     for (unsigned int k = 0; k < _ARRAYSIZE(Ept->PteForFirstLargePage); ++k)
  37.                     {
  38.                         MTRR_MEMORY_TYPE MemType = MTRR_MEMORY_TYPE::Uncacheable;
  39.  
  40.                         if (MtrrInfo->IsSupported)
  41.                         {
  42.                             MemType = GetMtrrMemoryType(MtrrInfo, PFN_TO_PAGE(static_cast<unsigned long long>(k)), PAGE_SIZE);
  43.                         }
  44.  
  45.                         Ept->PteForFirstLargePage[k].Page4Kb.ReadAccess = TRUE;
  46.                         Ept->PteForFirstLargePage[k].Page4Kb.WriteAccess = TRUE;
  47.                         Ept->PteForFirstLargePage[k].Page4Kb.ExecuteAccess = TRUE;
  48.                         Ept->PteForFirstLargePage[k].Page4Kb.Type = static_cast<unsigned char>(MemType);
  49.                         Ept->PteForFirstLargePage[k].Page4Kb.PagePhysicalPfn = k;
  50.                     }
  51.                 }
  52.                 else
  53.                 {
  54.                     unsigned long long PagePfn = i * _ARRAYSIZE(Ept->Pde[i]) + j;
  55.                     constexpr unsigned long long LargePageSize = 2 * 1048576; // 2 Mb
  56.  
  57.                     MTRR_MEMORY_TYPE MemType = MTRR_MEMORY_TYPE::Uncacheable;
  58.  
  59.                     if (MtrrInfo->IsSupported)
  60.                     {
  61.                         MemType = GetMtrrMemoryType(MtrrInfo, PFN_TO_LARGE_PAGE(PagePfn), LargePageSize);
  62.                     }
  63.  
  64.                     Ept->Pde[i][j].Page2Mb.ReadAccess = TRUE;
  65.                     Ept->Pde[i][j].Page2Mb.WriteAccess = TRUE;
  66.                     Ept->Pde[i][j].Page2Mb.ExecuteAccess = TRUE;
  67.                     Ept->Pde[i][j].Page2Mb.Type = static_cast<unsigned char>(MemType);
  68.                     Ept->Pde[i][j].Page2Mb.LargePage = TRUE;
  69.                     Ept->Pde[i][j].Page2Mb.PagePhysicalPfn = PagePfn;
  70.                 }
  71.             }
  72.         }
  73.     }
  74.  
  75.     ...
  76. }
  77.  
Здесь мы делаем "видимым" и доступным на чтение, запись и исполнение все 512 Гб физического адресного пространства, к которым процессор может запросить доступ, описывая их большими двухмегабайтными страницами.
А первую большую страницу (первые 2Мб) покрываем обычными страницами по 4 Кб, чтобы выставить типы кэширования на основе фиксированных MTRR без конфликтов.

И, наконец, соберём всё вместе, выделив все структуры и инициализировав все таблицы в функции VirtualizeAllProcessors:
Код (C):
  1.  
  2. namespace VMX
  3. {
  4.     ...
  5.  
  6.     static void DevirtualizeAllProcessors()
  7.     {
  8.         /* Nothing yet */
  9.     }
  10.  
  11.     static bool VirtualizeProcessor(__inout SHARED_VM_DATA* Shared)
  12.     {
  13.         UNREFERENCED_PARAMETER(Shared);
  14.         return false;
  15.     }
  16.  
  17.     static bool VirtualizeAllProcessors()
  18.     {
  19.         // Determining the max phys size:
  20.         CPUID::Intel::VIRTUAL_AND_PHYSICAL_ADDRESS_SIZES MaxAddrSizes = {};
  21.         __cpuid(MaxAddrSizes.Regs.Raw, CPUID::Intel::CPUID_VIRTUAL_AND_PHYSICAL_ADDRESS_SIZES);
  22.  
  23.         // Initializing MTRRs shared between all processors:
  24.         MTRR_INFO MtrrInfo;
  25.         memset(&MtrrInfo, 0, sizeof(MtrrInfo));
  26.         InitMtrr(&MtrrInfo);
  27.  
  28.         ULONG ProcessorsCount = KeQueryActiveProcessorCountEx(ALL_PROCESSOR_GROUPS);
  29.         g_Shared.Processors = VirtualMemory::AllocArray<PRIVATE_VM_DATA*>(ProcessorsCount);
  30.         for (ULONG i = 0; i < ProcessorsCount; ++i)
  31.         {
  32.             g_Shared.Processors[i] = reinterpret_cast<PRIVATE_VM_DATA*>(AllocPhys(sizeof(PRIVATE_VM_DATA), MmCached, MaxAddrSizes.Bitmap.PhysicalAddressBits));
  33.             if (!g_Shared.Processors[i])
  34.             {
  35.                 for (ULONG j = 0; j < ProcessorsCount; ++j)
  36.                 {
  37.                     if (g_Shared.Processors[j])
  38.                     {
  39.                         FreePhys(g_Shared.Processors[j]);
  40.                     }
  41.                 }
  42.  
  43.                 VirtualMemory::FreePoolMemory(g_Shared.Processors);
  44.                 g_Shared.Processors = NULL;
  45.  
  46.                 return false;
  47.             }
  48.  
  49.             InitializeEptTables(&MtrrInfo, OUT &g_Shared.Processors[i]->Ept);
  50.         }
  51.  
  52.         KeIpiGenericCall([](ULONG_PTR Arg) -> ULONG_PTR
  53.         {
  54.             auto* Shared = reinterpret_cast<SHARED_VM_DATA*>(Arg);
  55.             VirtualizeProcessor(Shared);
  56.             return TRUE;
  57.         }, reinterpret_cast<ULONG_PTR>(&g_Shared));
  58.  
  59.         bool Status = static_cast<unsigned int>(g_Shared.VirtualizedProcessors) == g_Shared.ProcessorsCount;
  60.         if (!Status)
  61.         {
  62.             DevirtualizeAllProcessors();
  63.             VirtualMemory::FreePoolMemory(g_Shared.Processors);
  64.             g_Shared.Processors = NULL;
  65.         }
  66.  
  67.         return Status;
  68.     }
  69.  
  70.     ...
  71. }
  72.  
Здесь мы выделили память под структуры для каждого логического процессора и инициализировали EPT для каждого.
С этими данными мы можем начинать перевод логических процессоров в виртуальное окружение.
Вызываем функцию-заготовку VirtualizeProcessor на каждом логическом процессоре через IPI и по итогам смотрим, сколько логических процессоров было виртуализовано.
Если были виртуализованы не все - считаем, что в процессе виртуализации произошла ошибка и снимаем виртуализацию полностью.

А наполнением заготовок займёмся в следующей части. Итоговый код в аттаче. Итоговый код не прикрепляется из-за 414 Request URI Too Large...
А на сегодня всё. Всем спасибо, все свободны.

1 645
HoShiMin

HoShiMin
Active Member

Регистрация:
17 дек 2016
Публикаций:
5

Комментарии


      1. HoShiMin 21 июн 2020
        Mikl___, глянь, что не так с nginx'ом? Не могу прикрепить архив в аттач - 414 Request URI Too Large.