VOID
FinishBenchMark (
IN PPERFINFO PerfInfo
)
{
ULONG ContextSwitches;
LARGE_INTEGER Duration;
ULONG FirstLevelFills;
ULONG InterruptCount;
ULONG Length;
ULONG Performance;
ULONG SecondLevelFills;
NTSTATUS Status;
ULONG SystemCalls;
SYSTEM_PERFORMANCE_INFORMATION SystemInfo;
//
// Print results and announce end of test.
//
NtQuerySystemTime((PLARGE_INTEGER)&PerfInfo->StopTime);
Status = NtQuerySystemInformation(SystemPerformanceInformation,
(PVOID)&SystemInfo,
sizeof(SYSTEM_PERFORMANCE_INFORMATION),
NULL);
if (NT_SUCCESS(Status) == FALSE) {
printf("Failed to query performance information, status = %lx\n", Status);
return;
}
Duration = RtlLargeIntegerSubtract(PerfInfo->StopTime, PerfInfo->StartTime);
Length = Duration.LowPart / 10000;
printf(" Test time in milliseconds %d\n", Length);
printf(" Number of iterations %d\n", PerfInfo->Iterations);
Performance = PerfInfo->Iterations * 1000 / Length;
printf(" Iterations per second %d\n", Performance);
ContextSwitches = SystemInfo.ContextSwitches - PerfInfo->ContextSwitches;
FirstLevelFills = SystemInfo.FirstLevelTbFills - PerfInfo->FirstLevelFills;
InterruptCount = SystemInfo.InterruptCount - PerfInfo->InterruptCount;
SecondLevelFills = SystemInfo.SecondLevelTbFills - PerfInfo->SecondLevelFills;
SystemCalls = SystemInfo.SystemCalls - PerfInfo->SystemCalls;
printf(" First Level TB Fills %d\n", FirstLevelFills);
printf(" Second Level TB Fills %d\n", SecondLevelFills);
printf(" Number of Interrupts %d\n", InterruptCount);
printf(" Total Context Switches %d\n", ContextSwitches);
printf(" Number of System Calls %d\n", SystemCalls);
printf("*** End of Test ***\n\n");
return;
}
int restrictEnabled() {
LARGE_INTEGER curtime, diff;
KeQuerySystemTime(&curtime);
diff = RtlLargeIntegerSubtract(curtime, Globals.DRIVERSTARTTIME);
if (RtlLargeIntegerGreaterThan(diff,
Globals.RESTRICT_STARTUP_TIMEOUT))
return 1;
return 0;
}
NTSTATUS MapPhysicalMemoryToLinearSpace(PVOID pPhysAddress,
ULONG PhysMemSizeInBytes,
PVOID *ppPhysMemLin,
HANDLE *pPhysicalMemoryHandle)
{
UNICODE_STRING PhysicalMemoryUnicodeString;
PVOID PhysicalMemorySection = NULL;
OBJECT_ATTRIBUTES ObjectAttributes;
PHYSICAL_ADDRESS ViewBase;
NTSTATUS ntStatus;
PHYSICAL_ADDRESS pStartPhysAddress;
PHYSICAL_ADDRESS pEndPhysAddress;
PHYSICAL_ADDRESS MappingLength;
BOOLEAN Result1, Result2;
ULONG IsIOSpace;
unsigned char *pbPhysMemLin = NULL;
OutputDebugString ("Entering MapPhysicalMemoryToLinearSpace");
RtlInitUnicodeString (&PhysicalMemoryUnicodeString,
L"\\Device\\PhysicalMemory");
InitializeObjectAttributes (&ObjectAttributes,
&PhysicalMemoryUnicodeString,
OBJ_CASE_INSENSITIVE,
(HANDLE) NULL,
(PSECURITY_DESCRIPTOR) NULL);
*pPhysicalMemoryHandle = NULL;
ntStatus = ZwOpenSection (pPhysicalMemoryHandle,
SECTION_ALL_ACCESS,
&ObjectAttributes);
if (NT_SUCCESS(ntStatus))
{
ntStatus = ObReferenceObjectByHandle (*pPhysicalMemoryHandle,
SECTION_ALL_ACCESS,
(POBJECT_TYPE) NULL,
KernelMode,
&PhysicalMemorySection,
(POBJECT_HANDLE_INFORMATION) NULL);
if (NT_SUCCESS(ntStatus))
{
pStartPhysAddress.QuadPart = (ULONGLONG)pPhysAddress;
pEndPhysAddress = RtlLargeIntegerAdd (pStartPhysAddress,
RtlConvertUlongToLargeInteger(PhysMemSizeInBytes));
IsIOSpace = 0;
Result1 = HalTranslateBusAddress (1, 0, pStartPhysAddress, &IsIOSpace, &pStartPhysAddress);
IsIOSpace = 0;
Result2 = HalTranslateBusAddress (1, 0, pEndPhysAddress, &IsIOSpace, &pEndPhysAddress);
if (Result1 && Result2)
{
MappingLength = RtlLargeIntegerSubtract (pEndPhysAddress, pStartPhysAddress);
if (MappingLength.LowPart)
{
// Let ZwMapViewOfSection pick a linear address
PhysMemSizeInBytes = MappingLength.LowPart;
ViewBase = pStartPhysAddress;
ntStatus = ZwMapViewOfSection (*pPhysicalMemoryHandle,
(HANDLE) -1,
&pbPhysMemLin,
0L,
PhysMemSizeInBytes,
&ViewBase,
&PhysMemSizeInBytes,
ViewShare,
0,
PAGE_READWRITE | PAGE_NOCACHE);
if (!NT_SUCCESS(ntStatus))
OutputDebugString ("ERROR: ZwMapViewOfSection failed");
else
{
pbPhysMemLin += (ULONG)pStartPhysAddress.LowPart - (ULONG)ViewBase.LowPart;
*ppPhysMemLin = pbPhysMemLin;
}
}
else
OutputDebugString ("ERROR: RtlLargeIntegerSubtract failed");
}
else
OutputDebugString ("ERROR: MappingLength = 0");
}
else
OutputDebugString ("ERROR: ObReferenceObjectByHandle failed");
}
else
OutputDebugString ("ERROR: ZwOpenSection failed");
if (!NT_SUCCESS(ntStatus))
ZwClose(*pPhysicalMemoryHandle);
OutputDebugString ("Leaving MapPhysicalMemoryToLinearSpace");
return ntStatus;
}
LARGE_INTEGER
SoundGetTime(
VOID
)
/*++
Routine Description:
Get an accurate estimate of the current time by calling
KeQueryPerformanceCounter and converting the result to 100ns units
NOTE: A driver should call this once during init to get the thing
safely started if it can be called from more than one device at a time
Arguments:
None
Return Value:
--*/
{
static struct {
LARGE_INTEGER StartTime100ns, StartTimeTicks, TicksPerSecond;
ULONG Multiplier;
BOOLEAN Initialized;
} s = { 1 }; // Move from BSS to reduce size
ULONG Remainder;
if (!s.Initialized) {
KeQuerySystemTime(&s.StartTime100ns);
s.StartTimeTicks = KeQueryPerformanceCounter(&s.TicksPerSecond);
s.Multiplier = 10000000;
while (s.TicksPerSecond.HighPart != 0) {
s.Multiplier = s.Multiplier / 10;
s.TicksPerSecond =
RtlExtendedLargeIntegerDivide(s.TicksPerSecond, 10, &Remainder);
}
s.Initialized = TRUE;
}
//
// Convert ticks to 100ns units (and hope we don't overflow!)
//
return RtlLargeIntegerAdd(
RtlExtendedLargeIntegerDivide(
RtlExtendedIntegerMultiply(
RtlLargeIntegerSubtract(
KeQueryPerformanceCounter(NULL),
s.StartTimeTicks
),
s.Multiplier
),
s.TicksPerSecond.LowPart,
&Remainder
),
s.StartTime100ns
);
}
