Public/winfsp
1
0
Fork 0
mirror of https://github.com/winfsp/winfsp.git synced 2025-04-23 17:03:12 -05:00
Code Issues Packages Projects Releases Wiki Activity

tst: winfsp-tests: oplock testing

Browse Source
This commit is contained in:
Bill Zissimopoulos 2016-11-23 15:41:28 -08:00
parent b6f084d71f
commit a894e4a2af
1 changed files with 122 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

247
tst/winfsp-tests/oplock-test.c
View File

@ -26,6 +26,8 @@ typedef struct
{ {
HANDLE File; HANDLE File;
HANDLE Wait; HANDLE Wait;
REQUEST_OPLOCK_INPUT_BUFFER OplockInputBuffer;
REQUEST_OPLOCK_OUTPUT_BUFFER OplockOutputBuffer;
OVERLAPPED Overlapped; OVERLAPPED Overlapped;
ULONG Information; ULONG Information;
HANDLE Semaphore; HANDLE Semaphore;
@ -40,17 +42,35 @@ static VOID CALLBACK OplockBreakWait(PVOID Context, BOOLEAN Timeout)
switch (Data->Information) switch (Data->Information)
{ {
case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE: default:
Data->Information = FSCTL_OPLOCK_BREAK_ACK_NO_2; Data->OplockInputBuffer.RequestedOplockLevel = Data->Information;
if (!DeviceIoControl(Data->File, FSCTL_OPLOCK_BREAK_ACKNOWLEDGE, 0, 0, 0, 0, &BytesTransferred, Data->OplockInputBuffer.Flags = REQUEST_OPLOCK_INPUT_FLAG_ACK;
&Data->Overlapped) && ERROR_IO_PENDING == GetLastError() && Data->Information = 0;
if ((Data->OplockOutputBuffer.Flags & REQUEST_OPLOCK_OUTPUT_FLAG_ACK_REQUIRED) &&
!DeviceIoControl(Data->File, FSCTL_REQUEST_OPLOCK,
&Data->OplockInputBuffer, sizeof Data->OplockInputBuffer,
&Data->OplockOutputBuffer, sizeof Data->OplockOutputBuffer,
&BytesTransferred, &Data->Overlapped) &&
ERROR_IO_PENDING == GetLastError() &&
RegisterWaitForSingleObject(&Data->Wait, Data->File, RegisterWaitForSingleObject(&Data->Wait, Data->File,
OplockBreakWait, Data, INFINITE, WT_EXECUTEONLYONCE)) OplockBreakWait, Data, INFINITE, WT_EXECUTEONLYONCE))
{ {
break; break;
} }
/* fall through! */ goto closefile;
default: case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE:
Data->Information = 0;
if (!DeviceIoControl(Data->File, FSCTL_OPLOCK_BREAK_ACKNOWLEDGE, 0, 0, 0, 0, &BytesTransferred,
&Data->Overlapped) &&
ERROR_IO_PENDING == GetLastError() &&
RegisterWaitForSingleObject(&Data->Wait, Data->File,
OplockBreakWait, Data, INFINITE, WT_EXECUTEONLYONCE))
{
break;
}
goto closefile;
case 0:
closefile:
CloseHandle(Data->File); CloseHandle(Data->File);
HeapFree(GetProcessHeap(), 0, Data); HeapFree(GetProcessHeap(), 0, Data);
break; break;
@ -77,8 +97,29 @@ static VOID RequestOplock(PWSTR FileName, ULONG RequestCode, ULONG BreakCode, HA
ASSERT(INVALID_HANDLE_VALUE != Data->File); ASSERT(INVALID_HANDLE_VALUE != Data->File);
Data->Information = BreakCode; Data->Information = BreakCode;
switch (RequestCode)
{
case FSCTL_REQUEST_OPLOCK_LEVEL_1:
case FSCTL_REQUEST_OPLOCK_LEVEL_2:
case FSCTL_REQUEST_BATCH_OPLOCK:
case FSCTL_REQUEST_FILTER_OPLOCK:
Success = DeviceIoControl(Data->File, RequestCode, 0, 0, 0, 0, &BytesTransferred, Success = DeviceIoControl(Data->File, RequestCode, 0, 0, 0, 0, &BytesTransferred,
&Data->Overlapped); &Data->Overlapped);
break;
default:
Data->OplockInputBuffer.StructureVersion = REQUEST_OPLOCK_CURRENT_VERSION;
Data->OplockInputBuffer.StructureLength = sizeof Data->OplockInputBuffer;
Data->OplockInputBuffer.RequestedOplockLevel = RequestCode;
Data->OplockInputBuffer.Flags = REQUEST_OPLOCK_INPUT_FLAG_REQUEST;
Success = DeviceIoControl(Data->File,
FSCTL_REQUEST_OPLOCK,
&Data->OplockInputBuffer, sizeof Data->OplockInputBuffer,
&Data->OplockOutputBuffer, sizeof Data->OplockOutputBuffer,
&BytesTransferred,
&Data->Overlapped);
break;
}
ASSERT(!Success); ASSERT(!Success);
ASSERT(ERROR_IO_PENDING == GetLastError()); ASSERT(ERROR_IO_PENDING == GetLastError());
@ -87,7 +128,8 @@ static VOID RequestOplock(PWSTR FileName, ULONG RequestCode, ULONG BreakCode, HA
ASSERT(Success); ASSERT(Success);
} }
static void oplock_level1_dotest(ULONG Flags, PWSTR Prefix) static void oplock_dotest(ULONG Flags, PWSTR Prefix,
ULONG RequestCode, ULONG BreakCode, ULONG WaitFlags)
{ {
void *memfs = memfs_start(Flags); void *memfs = memfs_start(Flags);
@ -110,24 +152,39 @@ static void oplock_level1_dotest(ULONG Flags, PWSTR Prefix)
ASSERT(INVALID_HANDLE_VALUE != Handle); ASSERT(INVALID_HANDLE_VALUE != Handle);
CloseHandle(Handle); CloseHandle(Handle);
RequestOplock(FilePath, FSCTL_REQUEST_OPLOCK_LEVEL_1, FSCTL_OPLOCK_BREAK_ACKNOWLEDGE, RequestOplock(FilePath, RequestCode, BreakCode, Semaphore);
Semaphore);
Handle = CreateFileW(FilePath, Handle = CreateFileW(FilePath,
GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
OPEN_EXISTING, 0, 0); OPEN_EXISTING, 0, 0);
ASSERT(INVALID_HANDLE_VALUE != Handle); ASSERT(INVALID_HANDLE_VALUE != Handle);
/* wait for level1 to level2 break */ if (WaitFlags & 1)
{
/* wait for oplock break after Create */
WaitResult = WaitForSingleObject(Semaphore, INFINITE); WaitResult = WaitForSingleObject(Semaphore, INFINITE);
ASSERT(WAIT_OBJECT_0 == WaitResult); ASSERT(WAIT_OBJECT_0 == WaitResult);
}
else
{
/* ensure no oplock break after Create */
WaitResult = WaitForSingleObject(Semaphore, 300);
ASSERT(WAIT_TIMEOUT == WaitResult);
}
Success = WriteFile(Handle, L"foobar", 6, &BytesTransferred, 0); Success = WriteFile(Handle, L"foobar", 6, &BytesTransferred, 0);
ASSERT(Success); ASSERT(Success);
/* wait for break to none */ if (WaitFlags & 2)
{
/* wait for any oplock break after Write */
WaitResult = WaitForSingleObject(Semaphore, INFINITE); WaitResult = WaitForSingleObject(Semaphore, INFINITE);
ASSERT(WAIT_OBJECT_0 == WaitResult); ASSERT(WAIT_OBJECT_0 == WaitResult);
}
/* ensure no additional oplock breaks */
WaitResult = WaitForSingleObject(Semaphore, 300);
ASSERT(WAIT_TIMEOUT == WaitResult);
Success = CloseHandle(Handle); Success = CloseHandle(Handle);
ASSERT(Success); ASSERT(Success);
@ -150,66 +207,15 @@ static void oplock_level1_test(void)
{ {
WCHAR DirBuf[MAX_PATH]; WCHAR DirBuf[MAX_PATH];
GetTestDirectory(DirBuf); GetTestDirectory(DirBuf);
oplock_level1_dotest(-1, DirBuf); oplock_dotest(-1, DirBuf,
FSCTL_REQUEST_OPLOCK_LEVEL_1, FSCTL_OPLOCK_BREAK_ACKNOWLEDGE, 3);
} }
if (WinFspDiskTests) if (WinFspDiskTests)
oplock_level1_dotest(MemfsDisk, 0); oplock_dotest(MemfsDisk, 0,
FSCTL_REQUEST_OPLOCK_LEVEL_1, FSCTL_OPLOCK_BREAK_ACKNOWLEDGE, 3);
if (WinFspNetTests) if (WinFspNetTests)
oplock_level1_dotest(MemfsNet, L"\\\\memfs\\share"); oplock_dotest(MemfsNet, L"\\\\memfs\\share",
} FSCTL_REQUEST_OPLOCK_LEVEL_1, FSCTL_OPLOCK_BREAK_ACKNOWLEDGE, 3);
static void oplock_level2_dotest(ULONG Flags, PWSTR Prefix)
{
void *memfs = memfs_start(Flags);
HANDLE Semaphore;
HANDLE Handle;
BOOLEAN Success;
WCHAR FilePath[MAX_PATH];
DWORD BytesTransferred;
DWORD WaitResult;
Semaphore = CreateSemaphoreW(0, 0, 2, 0);
ASSERT(0 != Semaphore);
StringCbPrintfW(FilePath, sizeof FilePath, L"%s%s\\file0",
Prefix ? L"" : L"\\\\?\\GLOBALROOT", Prefix ? Prefix : memfs_volumename(memfs));
Handle = CreateFileW(FilePath,
GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0);
ASSERT(INVALID_HANDLE_VALUE != Handle);
CloseHandle(Handle);
RequestOplock(FilePath, FSCTL_REQUEST_OPLOCK_LEVEL_2, 0,
Semaphore);
Handle = CreateFileW(FilePath,
GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
OPEN_EXISTING, 0, 0);
ASSERT(INVALID_HANDLE_VALUE != Handle);
Success = WriteFile(Handle, L"foobar", 6, &BytesTransferred, 0);
ASSERT(Success);
/* wait for break to none */
WaitResult = WaitForSingleObject(Semaphore, INFINITE);
ASSERT(WAIT_OBJECT_0 == WaitResult);
/* double check there isn't any remaining count on the semaphore */
WaitResult = WaitForSingleObject(Semaphore, 100);
ASSERT(WAIT_TIMEOUT == WaitResult);
Success = CloseHandle(Handle);
ASSERT(Success);
Success = DeleteFileW(FilePath);
ASSERT(Success);
Success = CloseHandle(Semaphore);
ASSERT(Success);
memfs_stop(memfs);
} }
static void oplock_level2_test(void) static void oplock_level2_test(void)
@ -221,66 +227,15 @@ static void oplock_level2_test(void)
{ {
WCHAR DirBuf[MAX_PATH]; WCHAR DirBuf[MAX_PATH];
GetTestDirectory(DirBuf); GetTestDirectory(DirBuf);
oplock_level2_dotest(-1, DirBuf); oplock_dotest(-1, DirBuf,
FSCTL_REQUEST_OPLOCK_LEVEL_2, 0, 2);
} }
if (WinFspDiskTests) if (WinFspDiskTests)
oplock_level2_dotest(MemfsDisk, 0); oplock_dotest(MemfsDisk, 0,
FSCTL_REQUEST_OPLOCK_LEVEL_2, 0, 2);
if (WinFspNetTests) if (WinFspNetTests)
oplock_level2_dotest(MemfsNet, L"\\\\memfs\\share"); oplock_dotest(MemfsNet, L"\\\\memfs\\share",
} FSCTL_REQUEST_OPLOCK_LEVEL_2, 0, 2);
static void oplock_batch_dotest(ULONG Flags, PWSTR Prefix, ULONG RequestCode)
{
void *memfs = memfs_start(Flags);
HANDLE Semaphore;
HANDLE Handle;
BOOLEAN Success;
WCHAR FilePath[MAX_PATH];
DWORD BytesTransferred;
DWORD WaitResult;
Semaphore = CreateSemaphoreW(0, 0, 2, 0);
ASSERT(0 != Semaphore);
StringCbPrintfW(FilePath, sizeof FilePath, L"%s%s\\file0",
Prefix ? L"" : L"\\\\?\\GLOBALROOT", Prefix ? Prefix : memfs_volumename(memfs));
Handle = CreateFileW(FilePath,
GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0);
ASSERT(INVALID_HANDLE_VALUE != Handle);
CloseHandle(Handle);
RequestOplock(FilePath, RequestCode, 0,
Semaphore);
Handle = CreateFileW(FilePath,
GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
OPEN_EXISTING, 0, 0);
ASSERT(INVALID_HANDLE_VALUE != Handle);
/* wait for break to none */
WaitResult = WaitForSingleObject(Semaphore, INFINITE);
ASSERT(WAIT_OBJECT_0 == WaitResult);
Success = WriteFile(Handle, L"foobar", 6, &BytesTransferred, 0);
ASSERT(Success);
/* double check there isn't any remaining count on the semaphore */
WaitResult = WaitForSingleObject(Semaphore, 100);
ASSERT(WAIT_TIMEOUT == WaitResult);
Success = CloseHandle(Handle);
ASSERT(Success);
Success = DeleteFileW(FilePath);
ASSERT(Success);
Success = CloseHandle(Semaphore);
ASSERT(Success);
memfs_stop(memfs);
} }
static void oplock_batch_test(void) static void oplock_batch_test(void)
@ -292,12 +247,15 @@ static void oplock_batch_test(void)
{ {
WCHAR DirBuf[MAX_PATH]; WCHAR DirBuf[MAX_PATH];
GetTestDirectory(DirBuf); GetTestDirectory(DirBuf);
oplock_batch_dotest(-1, DirBuf, FSCTL_REQUEST_BATCH_OPLOCK); oplock_dotest(-1, DirBuf,
FSCTL_REQUEST_BATCH_OPLOCK, 0, 1);
} }
if (WinFspDiskTests) if (WinFspDiskTests)
oplock_batch_dotest(MemfsDisk, 0, FSCTL_REQUEST_BATCH_OPLOCK); oplock_dotest(MemfsDisk, 0,
FSCTL_REQUEST_BATCH_OPLOCK, 0, 1);
if (WinFspNetTests) if (WinFspNetTests)
oplock_batch_dotest(MemfsNet, L"\\\\memfs\\share", FSCTL_REQUEST_BATCH_OPLOCK); oplock_dotest(MemfsNet, L"\\\\memfs\\share",
FSCTL_REQUEST_BATCH_OPLOCK, 0, 1);
} }
static void oplock_filter_test(void) static void oplock_filter_test(void)
@ -309,12 +267,38 @@ static void oplock_filter_test(void)
{ {
WCHAR DirBuf[MAX_PATH]; WCHAR DirBuf[MAX_PATH];
GetTestDirectory(DirBuf); GetTestDirectory(DirBuf);
oplock_batch_dotest(-1, DirBuf, FSCTL_REQUEST_FILTER_OPLOCK); oplock_dotest(-1, DirBuf,
FSCTL_REQUEST_FILTER_OPLOCK, 0, 1);
} }
if (WinFspDiskTests) if (WinFspDiskTests)
oplock_batch_dotest(MemfsDisk, 0, FSCTL_REQUEST_FILTER_OPLOCK); oplock_dotest(MemfsDisk, 0,
FSCTL_REQUEST_FILTER_OPLOCK, 0, 1);
if (WinFspNetTests) if (WinFspNetTests)
oplock_batch_dotest(MemfsNet, L"\\\\memfs\\share", FSCTL_REQUEST_FILTER_OPLOCK); oplock_dotest(MemfsNet, L"\\\\memfs\\share",
FSCTL_REQUEST_FILTER_OPLOCK, 0, 1);
}
static void oplock_rwh_test(void)
{
if (OptShareName || OptOplock)
return;
if (NtfsTests)
{
WCHAR DirBuf[MAX_PATH];
GetTestDirectory(DirBuf);
oplock_dotest(-1, DirBuf,
OPLOCK_LEVEL_CACHE_READ | OPLOCK_LEVEL_CACHE_WRITE | OPLOCK_LEVEL_CACHE_HANDLE,
OPLOCK_LEVEL_CACHE_READ | OPLOCK_LEVEL_CACHE_HANDLE, 3);
}
if (WinFspDiskTests)
oplock_dotest(MemfsDisk, 0,
OPLOCK_LEVEL_CACHE_READ | OPLOCK_LEVEL_CACHE_WRITE | OPLOCK_LEVEL_CACHE_HANDLE,
OPLOCK_LEVEL_CACHE_READ | OPLOCK_LEVEL_CACHE_HANDLE, 3);
if (WinFspNetTests)
oplock_dotest(MemfsNet, L"\\\\memfs\\share",
OPLOCK_LEVEL_CACHE_READ | OPLOCK_LEVEL_CACHE_WRITE | OPLOCK_LEVEL_CACHE_HANDLE,
OPLOCK_LEVEL_CACHE_READ | OPLOCK_LEVEL_CACHE_HANDLE, 3);
} }
static void oplock_not_granted_dotest(ULONG Flags, PWSTR Prefix) static void oplock_not_granted_dotest(ULONG Flags, PWSTR Prefix)
@ -387,5 +371,6 @@ void oplock_tests(void)
TEST(oplock_level2_test); TEST(oplock_level2_test);
TEST(oplock_batch_test); TEST(oplock_batch_test);
TEST(oplock_filter_test); TEST(oplock_filter_test);
TEST(oplock_rwh_test);
TEST(oplock_not_granted_test); TEST(oplock_not_granted_test);
} }