able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/buggy/driver/physmem.c

743 lines
17 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//
// Buggy.sys
// Copyright (c) Microsoft Corporation, 1999.
//
// Module: physmem.c
// Author: Silviu Calinoiu (SilviuC)
// Created: 4/20/1999 2:39pm
//
// This module contains stress functions for physical memory
// manipulation routines and also some pool allocaiton routines.
//
// --- History ---
//
// 08/14/99 (SilviuC): initial version (integrating code got from LandyW).
//
#include <ntddk.h>
#include "active.h"
#include "physmem.h"
#if !PHYSMEM_ACTIVE
//
// Dummy implementation if the module is inactive
//
LARGE_INTEGER BuggyOneSecond = {(ULONG)(-10 * 1000 * 1000 * 1), -1};
VOID PhysmemDisabled (VOID)
{
DbgPrint ("Buggy: physmem module is disabled (check \\driver\\active.h header) \n");
}
VOID
StressAllocateContiguousMemory (
PVOID NotUsed
)
{
PhysmemDisabled ();
}
VOID
StressAllocateCommonBuffer (
PVOID NotUsed
)
{
PhysmemDisabled ();
}
VOID
StressAddPhysicalMemory (
PVOID NotUsed
)
{
PhysmemDisabled ();
}
VOID
StressDeletePhysicalMemory (
PVOID NotUsed
)
{
PhysmemDisabled ();
}
VOID
StressLockScenario (
PVOID NotUsed
)
{
PhysmemDisabled ();
}
VOID
StressPhysicalMemorySimple (
PVOID NotUsed
)
{
PhysmemDisabled ();
}
#else
//
// Real implementation if the module is active
//
//////////////////////////
#define MAX_BUFFER_SIZE (2 * 1024 * 1024)
// #define BUFFER_SIZE (32 * 1024)
// ULONG uBufferSize = (64 * 1024);
ULONG uBufferSize = (4 * 1024);
int zlw = 3;
LARGE_INTEGER BuggyTenSeconds = {(ULONG)(-10 * 1000 * 1000 * 10), -1};
LARGE_INTEGER BuggyOneSecond = {(ULONG)(-10 * 1000 * 1000 * 1), -1};
VOID
StressAllocateContiguousMemory (
PVOID NotUsed
)
/*++
Routine Description:
Arguments:
Return Value:
Environment:
--*/
{
PHYSICAL_ADDRESS LogicalAddress;
PVOID VirtualAddress;
ULONG j;
ULONG i;
ULONG k;
PULONG_PTR p;
PVOID MyVirtualAddress[16];
PHYSICAL_ADDRESS MyLogicalAddress[16];
ULONG MySize[16];
PHYSICAL_ADDRESS LowestAcceptableAddress;
PHYSICAL_ADDRESS HighestAcceptableAddress;
PHYSICAL_ADDRESS BoundaryAddressMultiple;
MEMORY_CACHING_TYPE CacheType;
DbgPrint ("Buggy: MmAllocateContiguousMemorySpecifyCache stress ioctl \n");
//
// allocate the buffer
//
uBufferSize = (64 * 1024);
LowestAcceptableAddress.QuadPart = 0;
HighestAcceptableAddress.QuadPart = 0x100000;
BoundaryAddressMultiple.QuadPart = 0;
LogicalAddress.QuadPart = 0;
for (k = 0; k <= 12; k += 1) {
if (k < 4) {
LowestAcceptableAddress.QuadPart = 0;
HighestAcceptableAddress.QuadPart = 0x1000000;
BoundaryAddressMultiple.QuadPart = 0x10000;
}
else if (k < 4) {
LowestAcceptableAddress.QuadPart = 0x1000000;
HighestAcceptableAddress.QuadPart = 0x2000000;
BoundaryAddressMultiple.QuadPart = 0;
}
else {
LowestAcceptableAddress.QuadPart = 0x1800000;
HighestAcceptableAddress.QuadPart = 0x4000000;
BoundaryAddressMultiple.QuadPart = 0x30000;
}
for (CacheType = MmCached; CacheType <= MmWriteCombined; CacheType += 1) {
for (i = 0; i < 16; i += 1) {
DbgPrint( "buffer size = %08X\n", uBufferSize );
if (uBufferSize == 0) {
MyVirtualAddress[i] = NULL;
continue;
}
VirtualAddress = MmAllocateContiguousMemorySpecifyCache (
uBufferSize,
LowestAcceptableAddress,
HighestAcceptableAddress,
BoundaryAddressMultiple,
CacheType);
if (VirtualAddress == NULL) {
DbgPrint( "buggy: MmAllocateContiguousMemSpecifyCache( %08X ) failed\n",
(ULONG) uBufferSize );
// Status = STATUS_DRIVER_INTERNAL_ERROR;
MyVirtualAddress[i] = NULL;
}
else {
DbgPrint( "buggy: MmAllocateContiguousMemSpecifyCache( %p %08X ) - success\n",
VirtualAddress, (ULONG) uBufferSize);
MyVirtualAddress[i] = VirtualAddress;
MyLogicalAddress[i] = LogicalAddress;
MySize[i] = uBufferSize;
p = VirtualAddress;
for (j = 0; j < uBufferSize / sizeof(ULONG_PTR); j += 1) {
*p = ((ULONG_PTR)VirtualAddress + j);
p += 1;
}
}
uBufferSize -= PAGE_SIZE;
}
for (i = 0; i < 16; i += 1) {
if (MyVirtualAddress[i]) {
DbgPrint( "buggy: MmFreeContiguousMemorySpecifyCache( %x %08X )\n",
MyVirtualAddress[i], (ULONG) MySize[i]);
MmFreeContiguousMemorySpecifyCache (MyVirtualAddress[i],
MySize[i],
CacheType);
}
}
}
}
DbgPrint ("Buggy: MmAllocateContiguousMemSpecifyCache test finished\n");
}
VOID
StressAllocateCommonBuffer (
PVOID NotUsed
)
/*++
Routine Description:
Arguments:
Return Value:
Environment:
--*/
{
DEVICE_DESCRIPTION DeviceDescription; // DMA adapter object description
PADAPTER_OBJECT pAdapterObject; // DMA adapter object
ULONG NumberOfMapRegisters;
PHYSICAL_ADDRESS LogicalAddress;
PVOID VirtualAddress;
ULONG j;
ULONG i;
PULONG_PTR p;
PVOID MyVirtualAddress[16];
PHYSICAL_ADDRESS MyLogicalAddress[16];
ULONG MySize[16];
DbgPrint ("Buggy: HalAllocateCommonBuffer stress ioctl \n");
//
// Zero the device description structure.
//
RtlZeroMemory(&DeviceDescription, sizeof(DEVICE_DESCRIPTION));
//
// Get the adapter object for this card.
//
DeviceDescription.Version = DEVICE_DESCRIPTION_VERSION;
DeviceDescription.DmaChannel = 0;
DeviceDescription.InterfaceType = Internal;
DeviceDescription.DmaWidth = Width8Bits;
DeviceDescription.DmaSpeed = Compatible;
DeviceDescription.MaximumLength = MAX_BUFFER_SIZE;
DeviceDescription.BusNumber = 0;
pAdapterObject = HalGetAdapter (&DeviceDescription,
&NumberOfMapRegisters);
if ( pAdapterObject == NULL ) {
DbgPrint( "buggy: HalGetAdapter - failed\n" );
// return STATUS_DRIVER_INTERNAL_ERROR;
return;
}
DbgPrint( "buggy: HalGetAdapter - success\n" );
//
// allocate the buffer
//
uBufferSize = (64 * 1024);
for (i = 0; i < 16; i += 1) {
DbgPrint( "buffer size = %08X\n", uBufferSize );
VirtualAddress = HalAllocateCommonBuffer (pAdapterObject,
uBufferSize,
&LogicalAddress,
FALSE );
if (VirtualAddress == NULL) {
DbgPrint( "buggy: HalAllocateCommonBuffer( %08X ) failed\n",
(ULONG) uBufferSize );
// Status = STATUS_DRIVER_INTERNAL_ERROR;
MyVirtualAddress[i] = NULL;
}
else {
DbgPrint( "buggy: HalAllocateCommonBuffer( %p %08X ) - success\n",
VirtualAddress, (ULONG) uBufferSize);
MyVirtualAddress[i] = VirtualAddress;
MyLogicalAddress[i] = LogicalAddress;
MySize[i] = uBufferSize;
p = VirtualAddress;
for (j = 0; j < uBufferSize / sizeof(ULONG_PTR); j += 1) {
*p = ((ULONG_PTR)VirtualAddress + j);
p += 1;
}
}
uBufferSize -= PAGE_SIZE;
}
for (i = 0; i < 16; i += 1) {
if (MyVirtualAddress[i]) {
DbgPrint( "buggy: HalFreeCommonBuffer( %x %08X )\n",
MyVirtualAddress[i], (ULONG) MySize[i]);
HalFreeCommonBuffer(
pAdapterObject,
MySize[i],
MyLogicalAddress[i],
MyVirtualAddress[i],
FALSE );
}
}
DbgPrint ("Buggy: HalAllocateCommonBuffer test finished\n");
// LWFIX: Halfreeadapter needed ?
}
LOGICAL StopToEdit = TRUE;
PFN_NUMBER TestBasePage;
PFN_NUMBER TestPageCount;
VOID
EditPhysicalMemoryParameters (
)
/*++
Routine Description:
This function is called from StressAdd/DeletePhysicalMemory
to allow user to set the parameters for stress (what region should
be used for add/remove ?).
Arguments:
None.
Return Value:
None.
Environment:
Kernel mode.
--*/
{
DbgPrint ("`dd nt!mmphysicalmemoryblock l1' should give the address of memory descriptor\n");
DbgPrint ("`dd ADDRESS' (first dword displayed by previous command) gives description\n");
DbgPrint ("The structure of the memory descriptor is presented below: \n");
DbgPrint ("(4) NoOfRuns \n");
DbgPrint ("(4) NoOfPages \n");
DbgPrint ("(4) Run[0]: BasePage \n");
DbgPrint ("(4) Run[0]: PageCount \n");
DbgPrint ("(4) Run[1]: ... \n");
DbgPrint ("(4) ... \n");
DbgPrint (" \n");
DbgPrint ("When you decide on values you should edit the following: \n");
DbgPrint ("buggy!StopToEdit <- 0 \n");
DbgPrint ("buggy!TestBasePage <- decided value \n");
DbgPrint ("buggy!TestPageCount <- decided value \n");
DbgPrint (" \n");
DbgBreakPoint ();
}
VOID
StressAddPhysicalMemory (
PVOID NotUsed
)
/*++
Routine Description:
This function regresses the MmAddPhysicalMemory kernel API.
It does not really stress it but rather iterate through some
possible combinations.
Arguments:
None.
Return Value:
None.
Environment:
Kernel mode.
--*/
{
NTSTATUS Status;
ULONG i;
PHYSICAL_ADDRESS StartAddress;
LARGE_INTEGER NumberOfBytes;
DbgPrint ("Buggy: add physical memory stress ioctl \n");
//
// (SilviuC): We need an automatic way to figure out memory runs.
//
if (StopToEdit) {
EditPhysicalMemoryParameters ();
}
StartAddress.QuadPart = (LONGLONG)TestBasePage * PAGE_SIZE;
NumberOfBytes.QuadPart = (LONGLONG)TestPageCount * PAGE_SIZE;
i = 0;
do {
i += 1;
DbgPrint ("buggy: MmAddPhysicalMemory0 %x %x %x %x\n",
StartAddress.HighPart,
StartAddress.LowPart,
NumberOfBytes.HighPart,
NumberOfBytes.LowPart);
Status = MmAddPhysicalMemory (
&StartAddress,
&NumberOfBytes);
DbgPrint ("buggy: MmAddPhysicalMemory %x %x %x %x %x\n",
Status,
StartAddress.HighPart,
StartAddress.LowPart,
NumberOfBytes.HighPart,
NumberOfBytes.LowPart);
if ((i % 8) == 0) {
KeDelayExecutionThread (KernelMode, FALSE, &BuggyTenSeconds);
}
StartAddress.QuadPart -= NumberOfBytes.QuadPart;
} while (StartAddress.QuadPart > 0);
DbgPrint ("Buggy: MmAddPhysicalMemory test finished\n");
}
VOID
StressDeletePhysicalMemory (
PVOID NotUsed
)
/*++
Routine Description:
This function regresses the MmRemovePhysicalMemory kernel API.
It does not really stress the function but rather iterate
throughout the physical memory and attempt to remove chunks of it.
Arguments:
None.
Return Value:
None.
Environment:
Kernel mode.
--*/
{
NTSTATUS Status;
ULONG i;
PHYSICAL_ADDRESS StartAddress;
LARGE_INTEGER NumberOfBytes;
//
// SilviuC: we need an automatic way to figure out memory runs.
//
if (StopToEdit) {
EditPhysicalMemoryParameters ();
}
StartAddress.QuadPart = (LONGLONG)TestBasePage * PAGE_SIZE;
NumberOfBytes.QuadPart = (LONGLONG)TestPageCount * PAGE_SIZE;
for (i = 0; i < (0xf0000000 / NumberOfBytes.LowPart); i += 1) {
DbgPrint ("buggy: MmRemovePhysicalMemory0 %x %x %x %x\n",
StartAddress.HighPart,
StartAddress.LowPart,
NumberOfBytes.HighPart,
NumberOfBytes.LowPart);
Status = MmRemovePhysicalMemory (
&StartAddress,
&NumberOfBytes);
DbgPrint ("buggy: MmRemovePhysicalMemory %x %x %x %x %x\n",
Status,
StartAddress.HighPart,
StartAddress.LowPart,
NumberOfBytes.HighPart,
NumberOfBytes.LowPart);
StartAddress.QuadPart += NumberOfBytes.QuadPart;
if ((i % 8) == 0) {
KeDelayExecutionThread (KernelMode, FALSE, &BuggyTenSeconds);
}
}
DbgPrint ("Buggy: MmRemovePhysicalMemory test finished\n");
}
//
// Global:
//
// BigData
//
// Description:
//
// Dummy pageable array needed to test lock/unlock scenarios.
//
NTSTATUS
DriverEntry (
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
);
#ifdef ALLOC_PRAGMA
#pragma data_seg("BDAT")
ULONG BigData [0x10000];
#pragma data_seg()
#endif // #ifdef ALLOC_PRAGMA
VOID
StressLockScenario (
PVOID NotUsed
)
/*++
Routine Description:
Arguments:
Return Value:
Environment:
--*/
{
ULONG I;
PVOID Handle;
#if 0
for (I = 0; I < 16; I++) {
Handle = MmLockPagableDataSection (BigData);
DbgPrint ("Buggy: lock handle %p \n", Handle);
MmUnlockPagableImageSection (Handle);
}
#else
for (I = 0; I < 16; I++) {
MmPageEntireDriver (DriverEntry);
MmResetDriverPaging (BigData);
}
#endif
}
VOID
StressPhysicalMemorySimple (
PVOID NotUsed
)
/*++
Routine Description:
This routine exercises add/remove physical memory functions
using a simple remove scenario.
Note. This function contributed by LandyW.
Arguments:
None.
Return Value:
None.
Environment:
Kernel mode.
--*/
{
#if 0
ULONG i;
PPHYSICAL_MEMORY_RANGE Ranges;
PPHYSICAL_MEMORY_RANGE p;
PHYSICAL_ADDRESS StartAddress;
LARGE_INTEGER NumberOfBytes;
PHYSICAL_ADDRESS InputAddress;
LARGE_INTEGER InputBytes;
Ranges = MmGetPhysicalMemoryRanges ();
if (Ranges == NULL) {
DbgPrint ("Buggy: MmRemovePhysicalMemory cannot get ranges\n");
Status = STATUS_INSUFFICIENT_RESOURCES;
return;
}
p = Ranges;
while (p->BaseAddress.QuadPart != 0 && p->NumberOfBytes.QuadPart != 0) {
StartAddress.QuadPart = p->BaseAddress.QuadPart;
NumberOfBytes.QuadPart = p->NumberOfBytes.QuadPart;
InputAddress.QuadPart = StartAddress.QuadPart;
InputBytes.QuadPart = NumberOfBytes.QuadPart;
if (InputBytes.QuadPart > (128 * 1024 * 1024)) {
InputBytes.QuadPart = (128 * 1024 * 1024);
}
while (InputAddress.QuadPart + InputBytes.QuadPart <=
StartAddress.QuadPart + NumberOfBytes.QuadPart) {
DbgPrint ("buggy: MmRemovePhysicalMemory0 %x %x %x %x\n",
InputAddress.HighPart,
InputAddress.LowPart,
InputBytes.HighPart,
InputBytes.LowPart);
Status = MmRemovePhysicalMemory (&InputAddress,
&InputBytes);
DbgPrint ("buggy: MmRemovePhysicalMemory %x %x %x %x %x\n\n",
Status,
InputAddress.HighPart,
InputAddress.LowPart,
InputBytes.HighPart,
InputBytes.LowPart);
KeDelayExecutionThread (KernelMode, FALSE, &BuggyOneSecond);
if (NT_SUCCESS(Status)) {
DbgPrint ("buggy: MmAddPhysicalMemory0 %x %x %x %x\n",
InputAddress.HighPart,
InputAddress.LowPart,
InputBytes.HighPart,
InputBytes.LowPart);
Status = MmAddPhysicalMemory (
&InputAddress,
&InputBytes);
if (NT_SUCCESS(Status)) {
DbgPrint ("\n\n***************\nbuggy: MmAddPhysicalMemory WORKED %x %x %x %x %x\n****************\n",
Status,
InputAddress.HighPart,
InputAddress.LowPart,
InputBytes.HighPart,
InputBytes.LowPart);
}
else {
DbgPrint ("buggy: MmAddPhysicalMemory FAILED %x %x %x %x %x\n\n",
Status,
InputAddress.HighPart,
InputAddress.LowPart,
InputBytes.HighPart,
InputBytes.LowPart);
DbgBreakPoint ();
}
}
if (InputAddress.QuadPart + InputBytes.QuadPart ==
StartAddress.QuadPart + NumberOfBytes.QuadPart) {
break;
}
InputAddress.QuadPart += InputBytes.QuadPart;
if (InputAddress.QuadPart + InputBytes.QuadPart >
StartAddress.QuadPart + NumberOfBytes.QuadPart) {
InputBytes.QuadPart = StartAddress.QuadPart + NumberOfBytes.QuadPart - InputAddress.QuadPart;
}
}
p += 1;
}
ExFreePool (Ranges);
DbgPrint ("Buggy: Add/remove physical memory simple stress finished\n");
#endif // #if 0
}
#endif // #if !PHYSMEM_ACTIVE
Reference in a new issue Copy permalink