main.cpp

#define NOCOMM
#define NOHELP
#define NOGDICAPMASKS
#define NOMENUS
#define NOSHOWWINDOW
#define NOGDI
#define NOSOUND
#define NOMSG
#define WIN32_LEAN_AND_MEAN

#include <iostream>
#include <Windows.h>
#include <winioctl.h>
#include <x86intrin.h>
#include <string>

extern "C" void Copy_Wide_Char(char* dst, void* src, unsigned int count);
extern "C" unsigned int Int32ToChar_AVX2(char* dst, unsigned int x);
extern "C" unsigned long long String_To_Int_AVX2(char* str);


double frequency = 0.0;

const unsigned int BLOCK = 4096;
const unsigned int MAX_FOLDERS = 10000;
const unsigned int MAX_FILES = 100000;

//Get-Disk | Get-StorageReliabilityCounter | Select-Object -Property "*"

//NTFS File Record Header Structure Version 3.1
typedef struct _FILE_RECORD_SEGMENT_HEADER {
	UCHAR Signature[4];
	USHORT UpdateSequenceArrayOffset;
	USHORT UpdateSequenceArraySize;
	ULONGLONG Reserved1;
	USHORT SequenceNumber;
	USHORT Reserved2;
	USHORT FirstAttributeOffset;
	USHORT Flags;
	ULONG ActualSize;
	ULONG AllocatedSize;
	ULONG SegmentNumberLowPart;
	USHORT SegmentNumberHighPart;
	USHORT ReferenceSequenceNumber;
	USHORT NextAttributeID;
	USHORT Padding;
	ULONG MFTRecordNumber;
} FILE_RECORD_SEGMENT_HEADER, * PFILE_RECORD_SEGMENT_HEADER;

typedef struct _ATTRIBUTE_RECORD_HEADER {
	ULONG TypeCode;
	ULONG RecordLength;
	UCHAR FormCode;
	UCHAR NameLength;
	USHORT NameOffset;
	USHORT Flags;
	USHORT Instance;
	union {
		struct {
			ULONG  ValueLength;
			USHORT ValueOffset;
			UCHAR  Reserved[2];
		} Resident;
		struct {
			ULONGLONG LowestVcn;
			ULONGLONG HighestVcn;
			USHORT   MappingPairsOffset;
			UCHAR    Reserved[6];
			LONGLONG AllocatedLength;
			LONGLONG FileSize;
			LONGLONG ValidDataLength;
			LONGLONG TotalAllocated;
		} Nonresident;
	} Form;
} ATTRIBUTE_RECORD_HEADER, * PATTRIBUTE_RECORD_HEADER;

/*
important notes for oneself
CloseHandle does nothing to the handle value.
*/
struct Files
{
	unsigned long long fileID;
	unsigned long long hash[8];
	unsigned int folderindex;
	unsigned int namelength;
	char name[256];
};
struct Folders
{
	char name[256];
};
struct File_Array
{
	char filename[256];
	unsigned int folder_index;
};
struct Folder_Array
{
	char pathname[256];
};
struct FileStruct_Enum
{
	unsigned long long number;
	unsigned long long parent;
};

unsigned int XorShift32(unsigned int& seed)
{
	seed ^= seed << 13;
	seed ^= seed >> 17;
	seed ^= seed << 5;
	return(seed);
}


void BuildFolders(Folder_Array* f, FileStruct_Enum* n, DWORD count, DWORD index = 0)
{
	unsigned long long tmp = n[index].number;
	std::string s = f[index].pathname;
	std::string t;
	t.reserve(256);
	for (int i = 0; i < count; i++)
	{
		if (n[i].parent == tmp)
		{
			if (n[i].parent == 0xffffffffffffffff)
				continue;
			n[i].parent = 0xffffffffffffffff;	//set to none.
			t = s + f[i].pathname;
			t._Copy_s(&f[i].pathname[0],256,t.length(),0);
			BuildFolders(f, n, count, i);
		}
	}
}


//Find all files on volume using MFT. Either build directories manually using root reference or use openbyId
DWORD Enumerate_Vol(char letter,Folder_Array* folders,File_Array* files,DWORD* filesizes)// "\\.\C:"
{
	std::string drive = std::to_string(letter);
	drive = drive + ":\\";
	HANDLE root = CreateFileA(drive.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_SEQUENTIAL_SCAN | FILE_FLAG_NO_BUFFERING, NULL);//FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_NO_BUFFERING
	if (root == INVALID_HANDLE_VALUE)
		return(0);

	const size_t BUFFER_SIZE = 16 * 1024;
	DWORD br = 0;	//bytes returned
	
	PUSN_RECORD record;	//windows 7 only V2. variable size.
	BYTE* output = (BYTE*)VirtualAlloc(NULL, BUFFER_SIZE, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);	//page aligned memory.

	if (!DeviceIoControl(root, FSCTL_READ_FILE_USN_DATA, NULL, 0, output, 4096, &br, NULL))	//only means to obtain drive directory.
		return(0);
	CloseHandle(root);
	FileStruct_Enum* tmp_folders = (FileStruct_Enum*)_aligned_malloc(sizeof(FileStruct_Enum) * MAX_FOLDERS, 32); //temp folders
	FileStruct_Enum* tmp_files = (FileStruct_Enum*)_aligned_malloc(sizeof(FileStruct_Enum) * MAX_FILES, 32); //temp folders
	if (!tmp_folders)
		return(0);
	if (!tmp_files)
	{
		_aligned_free(tmp_folders);
		return(0);
	}

	memset(tmp_folders, 0, sizeof(FileStruct_Enum) * MAX_FOLDERS);
	memset(tmp_files, 0, sizeof(FileStruct_Enum) * MAX_FILES);

	record = (PUSN_RECORD)&output[0];
	tmp_folders[0].number = record->FileReferenceNumber;	//root number equals parent also.
	tmp_folders[0].parent = 0xffffffffffffffff;	//has parent value. unknown. maybe volume.
	drive._Copy_s(&folders[0].pathname[0],256,drive.length(),0);

	NTFS_VOLUME_DATA_BUFFER vol_data;
	if (!DeviceIoControl(root, FSCTL_GET_NTFS_VOLUME_DATA, NULL, 0, &vol_data, sizeof(vol_data), &br, NULL))	//list volume information
		return(0);
	unsigned long long total = vol_data.MftValidDataLength.QuadPart / vol_data.BytesPerFileRecordSegment;	//estimate number of files
	std::cout << "Estimated Number of files: " << total << std::endl;
	USN_JOURNAL_DATA jd = { 0 };
	if (!DeviceIoControl(root, FSCTL_QUERY_USN_JOURNAL, NULL, 0, &jd, sizeof(jd), &br, NULL))	//query nextUSN
		return(0);
	MFT_ENUM_DATA enum_data = { 0 };
	enum_data.StartFileReferenceNumber = 0;	//enumeration start position on volume
	enum_data.LowUsn = (DWORDLONG)0;	//lower boundary
	enum_data.HighUsn = jd.NextUsn;//INT64_MAX; //higher boundary
	unsigned int index = 0; //files
	unsigned int f = 1; //folders + drive directory

	while (true)
	{
		br = 0;
		if (DeviceIoControl(root, FSCTL_ENUM_USN_DATA, &enum_data, sizeof(enum_data), output, BUFFER_SIZE, &br, NULL) == false) //list MFT contents
			break;
		if (br == 0)
			break;
		enum_data.StartFileReferenceNumber = *(DWORDLONG*)&output[0]; //update start point

	DWORD i = 8;	//ignore first QWORD containing next start usn???

	while (i < br)
	{
		record = (PUSN_RECORD)&output[i];
		i = i + record->RecordLength;
		if ((record->FileAttributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_HIDDEN)) == 0) //files only
		{
			tmp_files[index].number = record->FileReferenceNumber;
			tmp_files[index].parent = record->ParentFileReferenceNumber;
			Copy_Wide_Char(files[index].filename, (char*)((char*)record + record->FileNameOffset), (DWORD)record->FileNameLength);
			index++;
		}
		else if ((record->FileAttributes & FILE_ATTRIBUTE_HIDDEN) == 0)	//folders only
		{
			tmp_folders[f].number = record->FileReferenceNumber;
			tmp_folders[f].parent = record->ParentFileReferenceNumber;
			Copy_Wide_Char(folders[f].pathname, (char*)((char*)record + record->FileNameOffset), (DWORD)record->FileNameLength);
			folders[f].pathname[(DWORD)record->FileNameLength / 2] = '\\';	//add backslash. Divide wide bytes by 2.
			f++;
		}
	}
	}
	BuildFolders(&folders[0], &tmp_folders[0], f, 0);	//get folder structures using recursion.
	//get file folders
	for (int i = 0; i < index; i++)
	{
		for (int j = 0; j < f; j++)
		{
			if (tmp_files[i].parent == tmp_folders[j].number)
			{
				files[i].folder_index = j;
				break;
			}
		}
	}
	//get File Size
	FILE_ID_DESCRIPTOR file;
	file.dwSize = sizeof(file);
	file.Type = FileIdType;
	FILE_STANDARD_INFO info;
	
	for (int i = 0; i < index; i++)
	{
		file.FileId.QuadPart = tmp_files[i].number;
		HANDLE h = OpenFileById(root, &file, 0, 0, NULL, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN | FILE_FLAG_NO_BUFFERING);
		GetFileInformationByHandleEx(h, FileStandardInfo, &info, sizeof(info));
		filesizes[2 * i] = info.EndOfFile.LowPart;		//lower 32-bit filesize
		filesizes[2 * i + 1] = i;
		CloseHandle(h);
	}
	CloseHandle(root);
	_aligned_free(tmp_files);
	_aligned_free(tmp_folders);
	VirtualFree(output, BUFFER_SIZE, MEM_RELEASE);
	return(index);	//return number of files found
}


//fileID 8 bytes,hash 64 bytes,filename length 4 bytes, filename
void FindFiles(Files* FileList,Folders* folders, std::string& folder,unsigned int &d, unsigned int &k)
{
	// "C:\z\" "\\.\C" "C:\z\*" "\\.\C:"
	folder.copy(folders[d].name,folder.length(),0);
	unsigned int current_folder = d;
	d++;
	HANDLE h = CreateFileA(folder.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
	if (h == INVALID_HANDLE_VALUE)
	{
		std::cout << "\r\n" << "_Invalid input\r\n";
		return;
	}
	BYTE* buffer = (BYTE*)_aligned_malloc(16384, 64);
	while(true)
	{
		if (GetFileInformationByHandleEx(h, FileIdBothDirectoryInfo, buffer, 16384) == false)
		break;
	unsigned int n = 0;
	while (true)
	{
		FILE_ID_BOTH_DIR_INFO* index = (FILE_ID_BOTH_DIR_INFO*)&buffer[n];
		if ((index->FileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)//files
		{
			char* t = (char*)&index->FileName[0];
			Copy_Wide_Char(&FileList[k].name[0], t, index->FileNameLength / 2);
			FileList[k].namelength = index->FileNameLength / 2;		//filelength = size
			FileList[k].fileID = index->FileId.QuadPart;
			FileList[k].folderindex = current_folder;
			k++;
		}
		else if (index->FileName[0] != L'.')  //folders
		{
			char tmp[256] = { 0 };
			memset(tmp, 0, 256);
			Copy_Wide_Char(tmp, index->FileName, index->FileNameLength / 2);
			std::string t = folder + tmp + '\\';
			FindFiles(FileList, folders,t,d,k);	//recursion
		}
		if (index->NextEntryOffset == 0)
			break;
		n += index->NextEntryOffset;
	}
	}
_aligned_free(buffer);
CloseHandle(h);
}

void ReadSpeed(char letter,unsigned long long size,unsigned int buffer_size, unsigned int hx)
{
	char vol[] = "\\\\.\\X:"; //x: = volume+mft
	vol[4] = letter;
	unsigned long long read = 0;
	HANDLE h; HANDLE e[hx];
	h = CreateFileA(vol, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
	0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_SEQUENTIAL_SCAN | FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, 0);
	if (h == INVALID_HANDLE_VALUE)
	{
		std::cout << "handle error\n";
		Sleep(1000);
		return;
	}
	OVERLAPPED o[hx];
	bool r[hx];
	unsigned int k[hx];
	for (int i = 0; i < hx; i++)
	{
		e[i] = CreateEventA(0, false, false, 0);
		o[i].Offset = i * buffer_size; o[i].OffsetHigh = 0;
		o[i].Internal = 0; o[i].InternalHigh = 0;
		o[i].hEvent = e[i];
		k[i] = i;	r[i] = false;
	}
	BYTE* buffer = (BYTE*)_aligned_malloc(hx * buffer_size * 2, 64); //4Gb
	if (buffer == nullptr)
		return;
	DWORD bytes = 0;
	DWORD count = size / buffer_size;
	DWORD t = hx;
	std::cout << "test speed sequential read\r\n";
	bool Done = false;
	_mm_lfence();
	unsigned long long A = __rdtsc();
	_mm_lfence();
	while (true)
	{
			for (int i = 0; i < hx; i++)
			{
				if (!r[i])//done read
				{
					if (k[i] < count)
					{
						ReadFile(h, &buffer[i * buffer_size * 2], buffer_size, 0, &o[i]); //0 for async
						r[i] = true;
					}
				}
			}
		_mm_pause();
		for (int i = 0; i < hx; i++)
		{
			if (r[i])//to read
			{
				if (GetOverlappedResult(h, &o[i], &bytes, false)) //wait = blocking, getlasterror 997 = IO, 996 not signalled
				{
					read += bytes;
					k[i] = t; t++;
					r[i] = false;
					o[i].Internal = 0; o[i].InternalHigh = 0;
					o[i].Offset = k[i] * buffer_size; o[i].OffsetHigh = 0;
				}
			}
		}
			if(read >= size)
			break;
	}

	_mm_lfence();
	unsigned long long B = __rdtsc();
	_mm_lfence();
	double temp = (double)(B - A) / frequency;
	std::cout << "Bytes Read " << (read >> 20) << "Mb. Speed " << (read >> 20) / temp << "mb/s\r\n";
	CancelIo(h);
	CloseHandle(h);
	for (int i = 0; i < hx; i++)
	{
		CloseHandle(e[i]);
	}
	_aligned_free(buffer);
}

void RandReadSpeed(char letter,unsigned long long count,unsigned int buffer_size, unsigned int hx)
{
	unsigned int mod = 33554431;//128Gb max
	unsigned int x= 1337;
	char vol[] = "\\\\.\\X:"; //x: = volume+mft
	vol[4] = letter;
	unsigned long long read = 0;
	HANDLE h; HANDLE e[hx];
	h = CreateFileA(vol, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
	0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, 0);
	if (h == INVALID_HANDLE_VALUE)
	{
		std::cout << "handle error \n";
		Sleep(1000);
		return;
	}
	OVERLAPPED o[hx];
	bool r[hx];
	for (int i = 0; i < hx; i++)
	{
		e[i] = CreateEventA(0, false, false, 0);
		o[i].hEvent = e[i];
		x = XorShift32(x);
		o[i].Offset = i * 4096; o[i].OffsetHigh = 0;
		o[i].Internal = 0; o[i].InternalHigh = 0;
		r[i] = false;
	}
	BYTE* buffer = (BYTE*)_aligned_malloc(hx * buffer_size * 2, 64);
	if (buffer == nullptr)
		return;
	DWORD bytes = 0;
	DWORD t = hx;
	std::cout << "test speed random read\r\n";
	_mm_lfence();
	unsigned long long A = __rdtsc();
	_mm_lfence();
	while (true)
	{
		for (int i = 0; i < hx; i++)
		{
			if (!r[i])//done read
			{
					ReadFile(h, &buffer[i * buffer_size * 2], buffer_size, 0, &o[i]);
					r[i] = true;
			}
		}
		_mm_pause();
		for (int i = 0; i < hx; i++)
		{
			if (r[i])//to read
			{
				if (GetOverlappedResult(h, &o[i], &bytes, false)) //996 not signalled
				{
					x = XorShift32(x);
					t++;
					r[i] = false;
					read += bytes;
					o[i].Internal = 0; o[i].InternalHigh = 0;
					unsigned long long y = (x % mod) << 12;
					o[i].Offset = y & 0xffffffff; o[i].OffsetHigh = y >> 32;
				}
			}
		}
		if (t >= count)
			break;
	}
	_mm_lfence();
	unsigned long long B = __rdtsc();
	_mm_lfence();
	double temp = (double)(B - A) / frequency;
	std::cout << "Reads " << count << ". Speed " << (read >> 20) / temp << "mb/s. Time " << temp << "\n";
	CloseHandle(h);
	for (int i = 0; i < hx; i++)
	{
		CloseHandle(e[i]);
	}
	_aligned_free(buffer);
}

void Console_Settings()
{
	HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_SCREEN_BUFFER_INFOEX tmp;
	tmp.cbSize = sizeof(CONSOLE_SCREEN_BUFFER_INFOEX);
	GetConsoleScreenBufferInfoEx(h, &tmp);
	tmp.wAttributes = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN;
	tmp.dwSize.X = 80;//width
	tmp.dwSize.Y = 40;//height
	tmp.srWindow.Left = 0;
	tmp.srWindow.Top = 0;
	tmp.srWindow.Bottom = tmp.srWindow.Top + 40;
	tmp.srWindow.Right = tmp.srWindow.Left + 80;
	tmp.dwMaximumWindowSize.X = 120;
	tmp.dwMaximumWindowSize.Y = 60;
	tmp.ColorTable[0] = COLORREF(0x00222222);	//background
	tmp.ColorTable[7] = COLORREF(0x00eeeeee);	//text
	tmp.bFullscreenSupported = true;
	SetConsoleScreenBufferInfoEx(h, &tmp);
	CONSOLE_CURSOR_INFO info;
	info.bVisible = false;
	info.dwSize = 100;
	SetConsoleCursorInfo(h, &info);
}
void Console_Clear()
{
	HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD pos;
	pos.X = 0;
	pos.Y = 0;
	CONSOLE_SCREEN_BUFFER_INFOEX tmp;
	tmp.cbSize = sizeof(CONSOLE_SCREEN_BUFFER_INFOEX);
	GetConsoleScreenBufferInfoEx(h, &tmp);
	DWORD size = tmp.dwSize.X * tmp.dwSize.Y;
	DWORD chars = 0;
	FillConsoleOutputCharacterA(h,' ', size, pos, &chars);
	SetConsoleCursorPosition(h, pos);
}
void Console_Move()
{
	HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD pos;
	pos.X = 0;
	pos.Y = 0;
	SetConsoleCursorPosition(h, pos);
}
void Console_Print(const char* text, WORD colour = 7) //bgr 124
{
	HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleTextAttribute(h, colour);
	WriteConsoleA(h, text, strlen(text), NULL, NULL);
}
unsigned int Console_ReadLine(char* out, DWORD count)
{
	DWORD chars = 0;
	HANDLE h = GetStdHandle(STD_INPUT_HANDLE);
	ReadConsoleA(h, out, count, &chars, NULL);
	for (int i = 0; i < count; i++)
	{
		if (out[i] == '\r') //remove \r\n
		{
			out[i] = 0; out[i + 1] = 0;
			break;
		}
		else if (out[i] == 0)
			break;
	}
	FlushConsoleInputBuffer(h);
	return(chars);
}
//c: = volume inc MFT, c:\ = root directory, PhysicalDrive# = raw disk
char vol[] = "\\\\.\\X:";//volume
char disk[] = "\\\\.\\PhysicalDrive0";//whole raw disk
struct drive_info
{
	CHAR number = -1;
	CHAR letter = -1;
	WORD pad = 0;
	WORD logical = 0;
	WORD physical = 0;
	unsigned long long offset = 0;
	unsigned long long extent = 0;
	unsigned long long totalsize = 0;
};

int main()
{
	HKEY hk; DWORD tmpf = 1; DWORD type = REG_DWORD; DWORD len = 4;
	RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", 0, KEY_READ | KEY_QUERY_VALUE, &hk);
	RegQueryValueExA(hk, "~Mhz", NULL, &type, (LPBYTE)&tmpf, &len);
	RegCloseKey(hk);
	frequency = (double)tmpf * 1.0e6;
	unsigned long long freq = tmpf * 1000000;

	Console_Settings();
	HANDLE h;
	DWORD bytes = 0;
	BYTE* buffer = (BYTE*)_aligned_malloc(32<<20, 64);
	unsigned long long totalsize = 12000000000000;
	unsigned long long pos_start = 0;
	char path[32] = { 0 };
	char text[192] = { 0 };


	Console_Print("Drive sequential read speed test, enter letter:");
	Console_ReadLine(text, 8);
	ReadSpeed(text[0], 2ULL << 30, 2 * 1024 * 1024, 2);
	RandReadSpeed(text[0], 20000, 4096, 8);

	
	Console_Print("Proceed to List Drives and drive burn-in overwrite testing(y):");
	Console_ReadLine(text, 8);
	if (text[0] != 'y')
	{
		return(0);
	}

	//======== Show List of available drives =============

	GetLogicalDriveStringsA(4096, (LPSTR)&buffer[4096]); //"X:\\",0
	drive_info* di = (drive_info*)buffer;
	for(int i = 0; i < 10; i++)
	{
		char l = buffer[4096 + i * 4];
		if (!l)
		break;
		vol[4] = l;
		h = CreateFileA(vol, FILE_READ_DATA, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
		if (h == INVALID_HANDLE_VALUE)//no more drives
			break;
		DeviceIoControl(h, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, 0, 0, &buffer[8192], 4096, &bytes, 0);
		CloseHandle(h);
		VOLUME_DISK_EXTENTS de = *(VOLUME_DISK_EXTENTS*)&buffer[8192];
		for (int j = 0; j < de.NumberOfDiskExtents; j++)
		{
			int k = de.Extents[j].DiskNumber;
			di[k].letter = l;
			di[k].offset = de.Extents[j].StartingOffset.QuadPart;
			di[k].extent = de.Extents[j].ExtentLength.QuadPart;
		}
	}
	for (int i = 0; i < 10; i++)
	{
		disk[17] = (char)(i + 48);//physicaldriveX
		h = CreateFileA(disk, FILE_READ_DATA, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
		if (h == INVALID_HANDLE_VALUE)
			continue;
		STORAGE_PROPERTY_QUERY hq;
		hq.PropertyId = StorageAccessAlignmentProperty; hq.QueryType = PropertyStandardQuery; hq.AdditionalParameters[0] = 0;
		DeviceIoControl(h, IOCTL_DISK_GET_LENGTH_INFO, 0, 0, &buffer[8192], 64, &bytes, 0); //total size disk
		DeviceIoControl(h, IOCTL_STORAGE_QUERY_PROPERTY, &hq, sizeof(hq), &buffer[4096], 4096, &bytes, 0); //logical size
		STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR ad = *(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR*)&buffer[4096];//logical, physical size
		//DeviceIoControl(h, IOCTL_DISK_GET_DRIVE_LAYOUT, 0, 0, &buffer[8192], 4096, &bytes, 0); //layout
		//DRIVE_LAYOUT_INFORMATION pt = *(DRIVE_LAYOUT_INFORMATION*)&buffer[8192];
		CloseHandle(h);
		di[i].totalsize = *(unsigned long long*) & buffer[8192];
		di[i].number = (char)(i + 48);
		di[i].logical = (WORD)ad.BytesPerLogicalSector;
		di[i].physical = (WORD)ad.BytesPerPhysicalSector;
		for (int m = 0; m < 192; m++)
			text[m] = 0;
		strcpy(text,"	DRIVE	\nPhysicalDrive");
		int l = strlen(text);
		text[l] = di[i].number;
		text[l + 1] = ' ';
		text[l + 2] = di[i].letter;
		strcpy(&text[strlen(text)], ":\nTotal Size ");
		Int32ToChar_AVX2(&text[strlen(text)], (di[i].totalsize >> 30));
		strcpy(&text[strlen(text)], " Gb. LogicalSize ");
		Int32ToChar_AVX2(&text[strlen(text)], di[i].logical);
		strcpy(&text[strlen(text)], " PhysicalSize ");
		Int32ToChar_AVX2(&text[strlen(text)], di[i].physical);
		strcpy(&text[strlen(text)], "\nPartition Offset ");
		Int32ToChar_AVX2(&text[strlen(text)], (di[i].offset >> 20));
		strcpy(&text[strlen(text)], " Mb Partition Size ");
		Int32ToChar_AVX2(&text[strlen(text)], (di[i].extent >> 30));
		strcpy(&text[strlen(text)], " Gb\n");
		Console_Print(text);
	}


	Console_Print("\nOverwrite Test\nEnter Drive Letter or Number:", 7); //BGR
	Console_ReadLine(text, 5);
	if ((text[0] > 'c') && (text[0] <= 'z'))
	{
		text[0] = text[0] - 32; //X: x:
		for (int i = 0; i < 10; i++)
		{
			if (di[i].letter == text[0])
			{
				strcpy(path, vol);
				path[4] = text[0];
				totalsize = di[i].extent;
				break;
			}
		}
	}
	else if ((text[0] >= '0') && (text[0] <= '9'))
	{
		for (int i = 0; i < 10; i++)
		{
			if (di[i].number == text[0])
			{
				if (di[i].letter == 'C')
				goto END_CODE;
				strcpy(path, disk);
				path[17] = text[0];
				totalsize = di[i].totalsize;
				break;
			}
		}
	}
	else
		goto END_CODE;
	Console_Print("\n");
	Console_Print(path);
	h = CreateFileA(path, FILE_READ_DATA | FILE_WRITE_DATA, 0, 0, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN | FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, 0);
	if (h == INVALID_HANDLE_VALUE)
	{
		Console_Print("\nHANDLE ERROR\n", 4);
		goto END_CODE;
	}
	Console_Print("\nStart position: X Gb",7);
	Console_ReadLine(text, 7);
	pos_start = String_To_Int_AVX2(text);
	pos_start = (pos_start << 30);
	if (pos_start > totalsize - (16ULL<<30))
		pos_start = 0;
	Console_Print("\nWARNING ALL DATA WILL BE ERASED WARNING ALL DATA WILL BE ERASED.\nConfirm: y?\n", 4);
	Console_ReadLine(text, 5);
	if (text[0] != 'y')
		return(0);
	Console_Clear();
	if (!DeviceIoControl(h, FSCTL_LOCK_VOLUME, 0, 0, 0, 0, &bytes, 0)) //raw access
	{
		Console_Print("\nLOCK ERROR\n", 4);
		goto END_CODE;
	}

	HANDLE e[2];
	OVERLAPPED ov[2];
	DWORD r[2] = { 0,1 }; //buffer position
	DWORD t = 0;
	unsigned long long pos = pos_start;
	DWORD rb[2];
	unsigned int speed[2] = { 0 };
	unsigned int errors = 0;
	const unsigned int rs = 2* 1024 * 1024; //2Mb optimal
	const unsigned long long cycle = 4ULL << 30;
	unsigned int state = 0;	//write,read
	unsigned long long tmp = 0;
	unsigned int value = 0xaaaaaaaa;
	memset(&buffer[4 * rs], value, 4*rs);
	for (int i = 0; i < 2; i++)
	{
		e[i] = CreateEventA(0, false, false, 0); //true state
		if (e[i] == INVALID_HANDLE_VALUE)
			goto END_CODE;
		ov[i].hEvent = e[i]; ov[i].Pointer = 0; ov[i].Internal = 0; ov[i].InternalHigh = 0;
		ov[i].Offset = (pos + 4*i * rs) & 0xffffffff;	ov[i].OffsetHigh = (pos + 4*i * rs) >> 32;
	}
	__m128 X = _mm_set1_epi32(value);
	unsigned long long start_time = __rdtsc();	//total
	unsigned long long seg_time = start_time;	//measure speed

	for (int k = 0; k < 2; k++)
	{
		WriteFile(h, &buffer[rs * 4], 4*rs, &rb[k], &ov[k]); //always returns zero
	}
	while (true)
	{
		for (int k = 0; k < 2; k++)
		{
			if (GetOverlappedResult(h, &ov[k], &bytes, false)) //getlasterror 5 = access denied
			{
				tmp += bytes;
				if (tmp < cycle)
				{
					if (state == 0)
					{
						ov[k].Offset = (pos + 4*rs + tmp) & 0xffffffff;	ov[k].OffsetHigh = (pos + 4*rs + tmp) >> 32;
						WriteFile(h, &buffer[rs * 4], 4*rs, &rb[k], &ov[k]); //always returns zero
					}
					else
					{
						ov[k].Offset = (pos + rs + tmp) & 0xffffffff;	ov[k].OffsetHigh = (pos + rs + tmp) >> 32;
						unsigned int p = r[k]; //prrevious buffer position
						t++; t = t % 4;
						r[k] = t * rs;
						ReadFile(h, &buffer[r[k]], rs, &rb[k], &ov[k]); //always returns zero
						for (int i = 0; i < rs; i += 32)
						{
							__m128 A = _mm_load_si128((__m128i*) & buffer[p + i]);
							__m128 B = _mm_load_si128((__m128i*) & buffer[p + i + 16]);
							errors += (_mm_movemask_epi8(_mm_cmpeq_epi32(A, X)) != 0xffff);
							errors += (_mm_movemask_epi8(_mm_cmpeq_epi32(B, X)) != 0xffff);
						}
					}
					speed[state] = ((tmp * freq) / (__rdtsc() - seg_time)) >> 20;
				}
				else
				{
					CancelIo(h);
					ResetEvent(e[0]);
					ResetEvent(e[1]);
					if (state == 1) //end of read
					{
						pos = pos + cycle;
						if (pos + cycle >= totalsize)
							pos = pos_start;
						//change pattern
						//value = XorShift32(value);
						//update write buffer
						//memset(&buffer[4 * rs], value, 4 * rs);
					}
					tmp = 0;
					state = (state + 1) & 1;	//write,read
					seg_time = __rdtsc();
					if (state == 1)
					{
						ov[0].Offset = pos & 0xffffffff;	ov[0].OffsetHigh = pos >> 32;
						ov[1].Offset = (pos + rs) & 0xffffffff;	ov[1].OffsetHigh = (pos + rs) >> 32;
						t++;	t = t % 4; r[0] = t * rs;
						ReadFile(h, &buffer[r[0]], rs, &rb[0], &ov[0]); //always returns zero
						t++;	t = t % 4; r[1] = t * rs;
						ReadFile(h, &buffer[r[1]], rs, &rb[1], &ov[1]); //always returns zero
					}
					else
					{
						ov[0].Offset = pos & 0xffffffff;	ov[0].OffsetHigh = pos >> 32;
						ov[1].Offset = (pos + 4*rs) & 0xffffffff;	ov[1].OffsetHigh = (pos + 4*rs) >> 32;
						WriteFile(h, &buffer[rs * 4], 4*rs, &rb[0], &ov[0]); //always returns zero
						WriteFile(h, &buffer[rs * 4], 4*rs, &rb[1], &ov[1]); //always returns zero
						for (int i = 0; i < rs; i += 32)
						{
							__m128 A = _mm_load_si128((__m128i*) & buffer[r[k] + i]);
							__m128 B = _mm_load_si128((__m128i*) & buffer[r[k] + i + 16]);
							errors += (_mm_movemask_epi8(_mm_cmpeq_epi32(A, X)) != 0xffff);
							errors += (_mm_movemask_epi8(_mm_cmpeq_epi32(B, X)) != 0xffff);
						}
						//update pattern
						//X = _mm_broadcastd_epi32(_mm_loadu_si32(&value));
					}
					Console_Clear();
					break;
				}

			}
		}
		Console_Move();
		for (int i = 0; i < 128; i++)
			text[i] = 0;
		strcpy(text, path);
		strcpy(&text[strlen(text)], "	");
		Int32ToChar_AVX2(&text[strlen(text)],(pos>>30));
		strcpy(&text[strlen(text)], "Gb/");
		Int32ToChar_AVX2(&text[strlen(text)],(totalsize>>30));
		strcpy(&text[strlen(text)], "Gb	Read ");
		Int32ToChar_AVX2(&text[strlen(text)],speed[1]);
		strcpy(&text[strlen(text)], "Mb/s	Write ");
		Int32ToChar_AVX2(&text[strlen(text)], speed[0]);
		strcpy(&text[strlen(text)], "Mb/s\nTime	");
		unsigned long long t = (__rdtsc() - start_time) / freq;
		unsigned int hour = t / 3600;
		unsigned int sec = t % 3600;
		Int32ToChar_AVX2(&text[strlen(text)],hour);
		strcpy(&text[strlen(text)], ":");
		Int32ToChar_AVX2(&text[strlen(text)],sec);
		strcpy(&text[strlen(text)], "\n");
		Int32ToChar_AVX2(&text[strlen(text)], tmp>>20);
		strcpy(&text[strlen(text)], " MB");
		Console_Print(text, 7);
		if(errors == 0)
		Console_Print("\n\nStatus Good", 2);
		else
		{
			strcpy(text, "\n\nErrors found ");
			Int32ToChar_AVX2(&text[strlen(text)], errors);
			Console_Print(text, 4);
		}
		WaitForMultipleObjects(2, e, false, 200);
	}

	





	/*
	//Attempt to obtain hard drive, SSD raw SMART data.

	BYTE* InBuffer = (BYTE*)_aligned_malloc(2*1024 * 1024, 64);
	BYTE* OutBuffer = &InBuffer[1024 * 1024];
	SENDCMDINPARAMS* params = (SENDCMDINPARAMS*)InBuffer;
	SENDCMDOUTPARAMS* info = (SENDCMDOUTPARAMS*)OutBuffer;
	params->bDriveNumber = 0;
	params->irDriveRegs.bCommandReg = SMART_CMD;
	params->irDriveRegs.bFeaturesReg = READ_ATTRIBUTES;// READ_ATTRIBUTES; //READ_ATTRIBUTES RETURN_SMART_STATUS
	params->irDriveRegs.bDriveHeadReg = 0;
	params->irDriveRegs.bCylLowReg = 0x4F;
	params->irDriveRegs.bCylHighReg = 0xC2;
	params->irDriveRegs.bSectorCountReg = 1;
	params->irDriveRegs.bSectorNumberReg = 1;
	params->cBufferSize = 65536;
	if( DeviceIoControl(h, SMART_RCV_DRIVE_DATA, InBuffer, 256*1024, OutBuffer, 256*1024, &bytes, 0) == false) // SMART_SEND_DRIVE_COMMAND or SMART_RCV_DRIVE_DATA
	{
		std::cout << "DeviceIO Error\n";
		std::cout << GetLastError();
	}
	//drive 1 = WD 12Tb power on hours = dword?
	std::cout << "Retrieve SMART Data\n\n"; //power on hours 12368
	std::cout << "Read bytes " << bytes << "\n";
	std::cout << "Size " << info->cBufferSize << "\n";
	unsigned short int t = 0;
	for (int i = 0; i < 500; i++)
	{
		t = *(unsigned int*)&info->bBuffer[i];
		std::cout << t << "\n";
	}
		_aligned_free(InBuffer);
		*/

	//Attempt to manually read NTFS MFT.
	/*
	h = CreateFileA("\\\\.\\c:", FILE_READ_DATA, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0); //open volume directly
	if (h == INVALID_HANDLE_VALUE)
	{
		std::cout << "HANDLE ERROR AA\r\n";
		Sleep(3000);
		return(0);
	}
	NTFS_VOLUME_DATA_BUFFER out = { 0 };
		DeviceIoControl(h, FSCTL_GET_NTFS_VOLUME_DATA, 0, 0, &out, sizeof(out), &bytes, 0);
		std::cout << "bytes per cluster " << out.BytesPerCluster << " total size " << (out.BytesPerCluster * out.TotalClusters.QuadPart >> 30) << "Gb." << std::endl;
		std::cout << "MFT lcn " << out.MftStartLcn.QuadPart << std::endl;

	long long MFT = out.MftStartLcn.QuadPart * out.BytesPerCluster;
	std::cout << "adjust by " << MFT << std::endl;
	if (SetFilePointerEx(h, *(LARGE_INTEGER*)&MFT, 0, 0))
	{
				std::cout << "read MFT\r\n";
				if (ReadFile(h, buffer, 1024 * 1024 * 256, &bytes, 0))
				{
					std::cout << "dword at 0 " << *(DWORD*)&buffer[0] << std::endl;
					std::cout << "qword at 0 " << *(long long*)&buffer[0] << std::endl;
					std::cout << (char)buffer[0] << (char)buffer[1] << (char)buffer[2] << (char)buffer[3] << std::endl;
				}
				else
					std::cout << "Error read MFT\r\n";
	}
	//get retrieval pointers -> non-resident / VCN's
			CloseHandle(h);
			*/	

	END_CODE:
	CloseHandle(h);
	_aligned_free(buffer);
	Sleep(600000);
	return(0);
}