archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
4.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/sdktools/clearmem/clearmem.c

828 lines
17 KiB
Raw Permalink Blame History

/*** ClearMem.C - Win 32 clear memory
*
*
* Title:
*
* ClearMem - Win 32 clear memory Main File
*
* Copyright (c) 1990-1994, Microsoft Corporation.
* Russ Blake.
*
*
* Description:
*
* This is the main part of the clear memory tool.
* It takes as a parameter a file to use to flush the memory.
*
* Usage: clearmem filename [-q] [-d]
*
* filename: name of file to use to flush the
* memory. Should be at least 128kb.
*
*
* The Clear Memory is organized as follows:
*
* o ClearMem.c ........ Tools main body
* o ClearMem.h
*
* o cmUtl.c ..... clear memory utility routines
* o cmUtl.h
*
*
*
*
*
*
* Modification History:
*
* 90.03.08 RussBl -- Created (copy of response probe)
* 92.07.24 MarkLea -- Added -t -w -b switches
* -- Modified AccessSection algorithm.
* 93.05.12 HonWahChan
* -- used total physical memory (instead of SECTION_SIZE);
* -- used GetTickCount() instead of timer calls.
*
*
*/
char *VERSION = "1.17x (93.05.12)";
/* * * * * * * * * * * * * I N C L U D E F I L E S * * * * * * * * * * */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <time.h>
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include "clearmem.h"
#include "cmUtl.h"
/* * * * * * * * * * G L O B A L D E C L A R A T I O N S * * * * * * * * */
/* none */
/* * * * * * * * * * F U N C T I O N P R O T O T Y P E S * * * * * * * * */
__cdecl main (int argc, char *argv[]);
STATIC RC Initialize (int argc, char *argv[]);
STATIC RC Cleanup (void);
STATIC RC FlushCache (void);
STATIC RC AccessSection (void);
STATIC RC ReadFlushFile (void);
void ParseCmdLine (int argc, char *argv[]);
void Usage (char *argv[], char *);
/* * * * * * * * * * * G L O B A L V A R I A B L E S * * * * * * * * * */
BOOL bQuiet,
bRead = TRUE,
bWrite;
BOOL bDebugBreakOnEntry;
ULONG ulMemSize,
ulPageCount,
ulTouchCount = 1;
ULONG_PTR ulSectionSize;
/* * * * * * E X P O R T E D G L O B A L V A R I A B L E S * * * * * */
/* none */
/********************************* m a i n **********************************
*
* main(argc, argv)
*
* ENTRY argc - number of input arguments
* argv - contains command line arguments
*
* EXIT -none-
*
* RETURN rc - return code in case of failure
* STATUS_SUCCESS - if successful
*
* WARNING:
* -none-
*
* COMMENT:
* -none-
*
*/
__cdecl main (int argc, char *argv[])
{
RC rc;
DWORD ulFlushTime; // Total time for flushing
ParseCmdLine (argc, argv);
if(ulMemSize){
ulSectionSize = ulMemSize * 1024 * 1024;
}
else {
// get total physical memory size in the system
MEMORYSTATUS MemStat;
GlobalMemoryStatus (&MemStat);
ulSectionSize = MemStat.dwTotalPhys;
}
// ExitProcess(STATUS_SUCCESS);
if (bDebugBreakOnEntry)
DebugBreak();
if (!bQuiet) {
//
// set initial total flushing time
//
ulFlushTime = GetTickCount() ;
}
//
// Do initialization
//
rc = Initialize(argc, argv);
if (Failed(rc, __FILE__, __LINE__, "main() - Initialize")) {
return(rc);
}
//
// Now flush the cache
//
rc = FlushCache();
if (Failed(rc, __FILE__, __LINE__, "main() - FlushCache")) {
return(rc);
}
if (!bQuiet) {
ulFlushTime = GetTickCount() - ulFlushTime;
printf("Elapsed Time for Flushing: %lu milliseconds \n", ulFlushTime);
}
//
// Cleanup
//
rc = Cleanup();
if (Failed(rc, __FILE__, __LINE__, "main() - Cleanup")) {
return(rc);
}
#ifdef CF_DEBUG_L1
if (!bQuiet) {
printf("| ==> Exiting PROCESS: %s \n", CF_EXE );
}
#endif
if (bDebugBreakOnEntry)
DebugBreak();
ExitProcess(STATUS_SUCCESS);
} /* main() */
/*************************** I n i t i a l i z e ****************************
*
* Initialize(argc, argv) -
* Performs basic initializations (getting input arguments,
* creating semaphores, display debug info, ...)
*
* ENTRY argc - number of input arguments
* argv - list of input arguments
*
* EXIT -none-
*
* RETURN rc - return code in case of failure
* STATUS_SUCCESS - if successful
*
* WARNING:
* -none-
*
* COMMENT:
* -none-
*
*/
STATIC RC Initialize (int argc, char *argv[])
{
int i;
//
// Sign on message
//
if (!bQuiet) {
printf("\nNT Win 32 Clear Memory.\n"
"Copyright 1990-1993, Microsoft Corporation.\n"
"Version %s\n\n", VERSION);
}
#ifdef CF_DEBUG_L1
//
// Display debugging info
//
if (!bQuiet) {
printf("/-------------------------------\n");
printf("| %s:\n", CF_EXE);
printf("|\n");
for (i=0; i<argc; i++) {
printf("| o argv[%i]=%s\n", i, argv[i]);
}
printf("\\-------------------------------\n");
}
#else
i; // Prevent compiler from complaining about unreferenced variable
#endif
return(STATUS_SUCCESS);
} /* Initialize() */
/****************************** C l e a n u p *******************************
*
* Cleanup(void) -
* Basic cleanup. (closing semaphores, freeing memory, ...)
*
* ENTRY -none-
*
* EXIT -none-
*
* RETURN rc - return code in case of failure
* STATUS_SUCCESS - if successful
*
* WARNING:
* -none-
*
* COMMENT:
* -none-
*
*/
STATIC RC Cleanup (void)
{
return(STATUS_SUCCESS);
} /* Cleanup() */
/************************ F l u s h C a c h e *****************************
*
* FlushCache(void) -
* Flushes the file cache by createing a large data
* segment, and touching every page to shrink the cache
* to 128kb, then reading in a 128kb file to clear the
* remaining cache
*
* ENTRY -none-
*
* EXIT -none-
*
* RETURN rc - return code in case of failure
* STATUS_SUCCESS - if successful
*
* WARNING:
* -none-
*
* COMMENT:
* -none-
*
*/
RC FlushCache (void)
{
RC rc;
//
// First touch all the data pages
//
#ifdef CF_DEBUG_L1
if (!bQuiet) {
printf("| ==> Start Flushing: Access Section of size: %lu \n",
ulSectionSize );
}
#endif
rc = AccessSection();
if (Failed(rc, __FILE__, __LINE__, "FlushCache() - AccessSection")) {
return(rc);
}
//
// Next read the flushing file to what's left of the cache
//
#ifdef CF_DEBUG_L1
if (!bQuiet) {
printf("| ==> Start Flushing: Read File: %s \n",
"FLUSH1" );
}
#endif
// while (ulTouchCount) {
rc = ReadFlushFile();
// --ulTouchCount;
if (Failed(rc, __FILE__, __LINE__, "FlushCache() - Read Flush File")) {
return(rc);
}
// }
return(STATUS_SUCCESS);
} /* FlushCache() */
/************************ A c c e s s S e c t i o n ************************
*
* AccessSection(void) -
* Touches every page in the data section
*
* ENTRY -none-
*
* EXIT -none-
*
* RETURN rc - return code in case of failure
* STATUS_SUCCESS - if successful
*
* WARNING:
* -none-
*
* COMMENT:
* -none-
*
*/
RC AccessSection (void)
{
RC rc;
ULONG uli,
ulj;
PULONG puSectionData; //Points to data section for flushing memory
//
// Allocate virtual memory
//
if ( (puSectionData = (PULONG)VirtualAlloc(NULL, // New allocation
ulSectionSize, // Size in bytes
MEM_RESERVE | MEM_COMMIT,
PAGE_READWRITE)) == NULL ) { //Changed to READWRITE
rc = GetLastError();
Failed(rc, __FILE__, __LINE__, "AccessSection() - VirtualAlloc");
return(rc);
}
//
// Now touch every page of the section
//
if(bWrite){
while (ulTouchCount) {
puSectionData = &puSectionData[0];
for ( uli = 0; uli < (ulSectionSize-1); uli+=sizeof(ULONG)) {
*puSectionData = 0xFFFFFFFF;
++puSectionData;
}
--ulTouchCount;
}
}
if(bRead) {
// DbgBreakPoint();
ulj = 0;
while (ulTouchCount) {
for ( uli = 0; uli < ulSectionSize; uli += PAGESIZE ) {
ulj += *(puSectionData+(uli/sizeof(ULONG)));
}
--ulTouchCount;
}
}
return(STATUS_SUCCESS);
} /* AccessSection() */
/************************ R e a d F l u s h F i l e ************************
*
* ReadFlushFile(void) -
* Touches every page in the flush file, non-sequentially
*
* ENTRY -none-
*
* EXIT -none-
*
* RETURN rc - return code in case of failure
* STATUS_SUCCESS - if successful
*
* WARNING:
* -none-
*
* COMMENT:
* -none-
*
*/
CHAR chBuffer[PAGESIZE];
RC ReadFlushFile (void)
{
RC rc;
SHORT sNewPos;
ULONG uli;
ULONG ulNumReads,
ulNumBytesRead;
BOOL bFileCreated;
SHORT sFile; // Indicates which of the three
// files is being used to flush
CHAR chFlushFileName1[] = "FLUSH1";
CHAR chFlushFileName2[] = "FLUSH2";
CHAR chFlushFileName3[] = "FLUSH3";
CHAR *pchFlushFileName[3] = { chFlushFileName1,
chFlushFileName2,
chFlushFileName3 };
FILE *pfFlushFile; // Points to the file used for
// flushing the cache
FILE *pfSaveFile[3]; // Remembers them for the close
CHAR achErrMsg[LINE_LEN];
//
// Assume no file is created: all three already exist
//
bFileCreated = FALSE;
for (sFile = 0; sFile < NUM_FILES; sFile++) {
//
// First attempt to create the file
//
if ( (pfFlushFile = CreateFile(pchFlushFileName[sFile],
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
CREATE_NEW,
0,
0))
== INVALID_HANDLE_VALUE ) {
//
// Could not create the file
//
rc = GetLastError();
if (!(rc == ERROR_FILE_EXISTS || rc == ERROR_ACCESS_DENIED)) {
//
// Cannot create a new file
//
sprintf(achErrMsg,
"ReadFlushFile() - Error creating %s: %lu",
pchFlushFileName[sFile], rc);
Failed(FILEARG_ERR, __FILE__, __LINE__, achErrMsg);
return(FILEARG_ERR);
}
}
else {
//
// New file has been created without difficulty
// Fill it with data
//
bFileCreated = TRUE;
for (uli = 0; uli < FLUSH_FILE_SIZE; uli += PAGESIZE) {
if (!WriteFile(pfFlushFile,
&chBuffer,
PAGESIZE,
&ulNumBytesRead,
RESERVED_NULL)) {
rc = GetLastError();
Failed(rc, __FILE__, __LINE__,
"ReadFlushFile() - Write File Record to New File");
return(rc);
}
}
//
// Now close it for write, so we can open it for read access
//
if (!CloseHandle(pfFlushFile)) {
rc = GetLastError();
sprintf(achErrMsg, "ReadFlushFile() - Error closing %s: %lu",
pchFlushFileName[sFile], rc);
Failed(FILEARG_ERR, __FILE__, __LINE__, achErrMsg);
return(FILEARG_ERR);
}
}
}
if (bFileCreated) {
//
// Wrote at least 1 file: wait for lazy writer to flush
// data to disk
//
Sleep(LAZY_DELAY);
}
for (sFile = 0; sFile < NUM_FILES; sFile++) {
if ((pfFlushFile = CreateFile( pchFlushFileName[sFile],
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
0,
0))
== INVALID_HANDLE_VALUE) {
//
// Cannot open an existing file
//
rc = GetLastError();
sprintf(achErrMsg,
"ReadFlushFile() - Error opening %s: %lu",
pchFlushFileName[sFile], rc);
Failed(FILEARG_ERR, __FILE__, __LINE__, achErrMsg);
return(FILEARG_ERR);
}
//
// Remember the handle for the close
//
pfSaveFile[sFile] = pfFlushFile;
//
// Read first record
//
if (!ReadFile( pfFlushFile,
&chBuffer,
1,
&ulNumBytesRead,
RESERVED_NULL)) {
rc = GetLastError();
Failed(rc, __FILE__, __LINE__,
"ReadFlushFile() - Read First Record");
return(rc);
}
ulNumReads = 1;
while (++ulNumReads <= ulPageCount) {
if (ulNumReads & 1) {
//
// Read an odd record: read previous record
// Move backward to start of prior record: -1 (start of
// this record) -4096 (start of previous record) = -4097
//
if (SetFilePointer( pfFlushFile, -4097, 0L, FILE_CURRENT) == (DWORD)-1) {
rc = GetLastError();
Failed(rc, __FILE__, __LINE__,
"ReadFlushFile() - Read Odd Record");
return(rc);
}
if (!ReadFile( pfFlushFile,
&chBuffer,
1,
&ulNumBytesRead,
RESERVED_NULL)) {
rc = GetLastError();
if (rc == ERROR_HANDLE_EOF)
break;
Failed(rc, __FILE__, __LINE__,
"ReadFlushFile() - SetPos Odd Record");
return(rc);
}
}
else {
//
// Read an even record: read the one after the next record
// Move forward to end of this record (4095) + 2 more
// (8192) = 12287. (But second record is special, 'cause
// can't set file pointer negative initially.)
//
sNewPos = (SHORT) (ulNumReads == 2L ? 8191 : 12287);
if (SetFilePointer( pfFlushFile, sNewPos, 0L, FILE_CURRENT) == (DWORD) -1) {
rc = GetLastError();
Failed(rc, __FILE__, __LINE__,
"ReadFlushFile() - Read Even Record");
return(rc);
}
if (!ReadFile( pfFlushFile,
&chBuffer,
1,
&ulNumBytesRead,
RESERVED_NULL)) {
rc = GetLastError();
if (rc == ERROR_HANDLE_EOF)
break;
Failed(rc, __FILE__, __LINE__,
"ReadFlushFile() - SetPos Even Record");
return(rc);
}
}
}
}
for (sFile = 0; sFile < NUM_FILES; sFile++) {
//
// Close the files
//
if (!CloseHandle(pfSaveFile[sFile])) {
rc = GetLastError();
sprintf(achErrMsg, "ReadFlushFile() - Error closing %s: %lu",
pchFlushFileName[sFile], rc);
Failed(FILEARG_ERR, __FILE__, __LINE__, achErrMsg);
return(FILEARG_ERR);
}
}
return(STATUS_SUCCESS);
} /* ReadFlushFile() */
/************************ R e a d F l u s h F i l e ************************
*
* parseCmdLine(void) -
* For Parsing the command line switches
*
* ENTRY -none-
*
* EXIT -none-
*
* RETURN -none-
*
* WARNING:
* -none-
*
* COMMENT:
* -none-
*
*/
VOID ParseCmdLine (int argc, char *argv[])
{
char *pchParam;
int iParamCount;
for ( iParamCount = 1; iParamCount < argc; iParamCount++) {
if (argv[iParamCount][0] == '-') { /* process options */
pchParam = &(argv[iParamCount][1]);
while (*pchParam) {
switch (*pchParam) {
case '?':
Usage (argv, " ");
break;
case 'Q':
case 'q':
pchParam++;
bQuiet = TRUE;
break;
case 'd':
case 'D': /* print banner */
pchParam++;
bDebugBreakOnEntry = TRUE;
break;
case 'm':
case 'M':
ulMemSize = (ULONG)atol(&pchParam[1]);
if (ulPageCount > 32) {
Usage (argv, "Mem size must be less than the amount of physical memory!");
}
pchParam += strlen(pchParam);
break;
case 'p':
case 'P':
ulPageCount = (ULONG)atol(&pchParam[1]);
if (ulPageCount > 63) {
Usage (argv, "Page Count must be 63 or less!");
}
pchParam += strlen(pchParam);
break;
case 't':
case 'T':
ulTouchCount = (ULONG)atol(&pchParam[1]);
pchParam += strlen(pchParam);
break;
case 'w':
case 'W':
bWrite = TRUE;
bRead = FALSE;
break;
case 'b':
case 'B':
bRead = TRUE;
bWrite = TRUE;
break;
default:
Usage (argv, "unknown flag");
break;
} // end of switch
} // end of while
} // end of if
} // end of for...
if(!ulPageCount){
ulPageCount = NUM_FLUSH_READS;
}
return;
}
/*
*
* Usage - generates a usage message and an error message
* and terminates program.
*
* Accepts - argv - char *[]
* message - char * - an error message
*
* Returns - nothing.
*
*/
VOID Usage (char *argv[], char *message)
{
printf( "%s\n", message);
printf( "usage: ");
printf( "%s [-q] [-d] [-mx] [-px] [-w] [-tx]\n", argv[0]);
printf( "\t-? : This message\n");
printf( "\t-q : Quiet mode - Nothing printed.\n");
printf( "\t-d : Debug break on Entry into and Exit from app.\n");
printf( "\t-m : Number of megabytes to allocate.\n");
printf( "\t : (default is to use all physical memory.)\n");
printf( "\t-p : Number of pages to read (must be less than 63).\n");
printf( "\t-w : Write to the virtual memory section.\n");
printf( "\t-b : Read and Write the virtual memory section.\n");
printf( "\t-t : Times to touch a page.\n");
printf( "**DEFAULT: clearmem -p63 -t1\n");
exit (1);
}