util.h

Go to the documentation of this file.

// Copyright (c) 2015-2017, Satoshi Tanda. All rights reserved.
// Use of this source code is governed by a MIT-style license that can be
// found in the LICENSE file.


#ifndef HYPERPLATFORM_UTIL_H_
#define HYPERPLATFORM_UTIL_H_

#include "ia32_type.h"

extern "C" {
//
// macro utilities
//

//
// constants and macros
//

//
// types
//

struct PhysicalMemoryRun {
  ULONG_PTR base_page;   
  ULONG_PTR page_count;  
};
#if defined(_AMD64_)
static_assert(sizeof(PhysicalMemoryRun) == 0x10, "Size check");
#else
static_assert(sizeof(PhysicalMemoryRun) == 0x8, "Size check");
#endif

struct PhysicalMemoryDescriptor {
  PFN_COUNT number_of_runs;    
  PFN_NUMBER number_of_pages;  
  PhysicalMemoryRun run[1];    
};
#if defined(_AMD64_)
static_assert(sizeof(PhysicalMemoryDescriptor) == 0x20, "Size check");
#else
static_assert(sizeof(PhysicalMemoryDescriptor) == 0x10, "Size check");
#endif

enum class VmxStatus : unsigned __int8 {
  kOk = 0,                  
  kErrorWithStatus = 1,     
  kErrorWithoutStatus = 2,  
};

constexpr VmxStatus operator|=(_In_ VmxStatus lhs, _In_ VmxStatus rhs) {
  return static_cast<VmxStatus>(static_cast<unsigned __int8>(lhs) |
                                static_cast<unsigned __int8>(rhs));
}

enum class HypercallNumber : unsigned __int32 {
  kTerminateVmm,            
  kPingVmm,                 
  kGetSharedProcessorData,  
};

//
// prototypes
//

_IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS
    UtilInitialization(_In_ PDRIVER_OBJECT driver_object);

_IRQL_requires_max_(PASSIVE_LEVEL) void UtilTermination();

void *UtilPcToFileHeader(_In_ void *address);

const PhysicalMemoryDescriptor *UtilGetPhysicalMemoryRanges();

_IRQL_requires_max_(APC_LEVEL) NTSTATUS
    UtilForEachProcessor(_In_ NTSTATUS (*callback_routine)(void *),
                         _In_opt_ void *context);

_IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS
    UtilForEachProcessorDpc(_In_ PKDEFERRED_ROUTINE deferred_routine,
                            _In_opt_ void *context);

_IRQL_requires_max_(APC_LEVEL) NTSTATUS UtilSleep(_In_ LONG millisecond);

void *UtilMemMem(_In_ const void *search_base, _In_ SIZE_T search_size,
                 _In_ const void *pattern, _In_ SIZE_T pattern_size);

void *UtilGetSystemProcAddress(_In_ const wchar_t *proc_name);

bool UtilIsX86Pae();

bool UtilIsAccessibleAddress(_In_ void *address);

ULONG64 UtilPaFromVa(_In_ void *va);

PFN_NUMBER UtilPfnFromVa(_In_ void *va);

PFN_NUMBER UtilPfnFromPa(_In_ ULONG64 pa);

void *UtilVaFromPa(_In_ ULONG64 pa);

ULONG64 UtilPaFromPfn(_In_ PFN_NUMBER pfn);

void *UtilVaFromPfn(_In_ PFN_NUMBER pfn);

_Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) void
    *UtilAllocateContiguousMemory(_In_ SIZE_T number_of_bytes);

_IRQL_requires_max_(DISPATCH_LEVEL) void UtilFreeContiguousMemory(
    _In_ void *base_address);

NTSTATUS UtilVmCall(_In_ HypercallNumber hypercall_number,
                    _In_opt_ void *context);

void UtilDumpGpRegisters(_In_ const AllRegisters *all_regs,
                         _In_ ULONG_PTR stack_pointer);

ULONG_PTR UtilVmRead(_In_ VmcsField field);

ULONG64 UtilVmRead64(_In_ VmcsField field);

VmxStatus UtilVmWrite(_In_ VmcsField field, _In_ ULONG_PTR field_value);

VmxStatus UtilVmWrite64(_In_ VmcsField field, _In_ ULONG64 field_value);

ULONG_PTR UtilReadMsr(_In_ Msr msr);

ULONG64 UtilReadMsr64(_In_ Msr msr);

void UtilWriteMsr(_In_ Msr msr, _In_ ULONG_PTR value);

void UtilWriteMsr64(_In_ Msr msr, _In_ ULONG64 value);

VmxStatus UtilInveptGlobal();

VmxStatus UtilInvvpidIndividualAddress(_In_ USHORT vpid, _In_ void *address);

VmxStatus UtilInvvpidSingleContext(_In_ USHORT vpid);

VmxStatus UtilInvvpidAllContext();

VmxStatus UtilInvvpidSingleContextExceptGlobal(_In_ USHORT vpid);

void UtilLoadPdptes(_In_ ULONG_PTR cr3_value);

_IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS
    UtilForceCopyMemory(_In_ void *destination, _In_ const void *source,
                        _In_ SIZE_T length);

//
// variables
//

//
// implementations
//

}  // extern "C"

template <typename T>
constexpr bool UtilIsInBounds(_In_ const T &value, _In_ const T &min,
                              _In_ const T &max) {
  return (min <= value) && (value <= max);
}

#endif  // HYPERPLATFORM_UTIL_H_