Public/winfsp
1
0
Fork 0
mirror of https://github.com/winfsp/winfsp.git synced 2025-07-29 14:02:55 -05:00
Code Issues Packages Projects Releases Wiki Activity

Major refactoring: WIP

Browse Source
This commit is contained in:
Bill Zissimopoulos
2015-12-20 10:57:45 -08:00
parent f099fe4bff
commit 7197501c9a
47 changed files with 2622 additions and 1982 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/dll/debug.c
View File

@@ -1,20 +0,0 @@
/**
* @file dll/debug.c
*
* @copyright 2015 Bill Zissimopoulos
*/
#include <dll/library.h>
#include <stdarg.h>
FSP_API VOID FspDebugLog(const char *format, ...)
{
char buf[1024];
/* DbgPrint has a 512 byte limit, but wvsprintf is only safe with a 1024 byte buffer */
va_list ap;
va_start(ap, format);
wvsprintfA(buf, format, ap);
va_end(ap);
buf[sizeof buf - 1] = '\0';
OutputDebugStringA(buf);
}

268
src/dll/fsctl.c
View File

@@ -1,268 +0,0 @@
/**
* @file dll/fsctl.c
*
* @copyright 2015 Bill Zissimopoulos
*/
#include <dll/library.h>
#if !defined(NDEBUG)
#include <sddl.h>
#endif
#define GLOBALROOT L"\\\\?\\GLOBALROOT"
static inline VOID GlobalDevicePath(PWCHAR DevicePathBuf, SIZE_T DevicePathSize, PWSTR DevicePath)
{
PWSTR DeviceRoot = L'\\' == DevicePath[0] ? GLOBALROOT : GLOBALROOT "\\Device\\";
SIZE_T RootSize = lstrlenW(DeviceRoot) * sizeof(WCHAR);
SIZE_T PathSize = lstrlenW(DevicePath) * sizeof(WCHAR) + sizeof(WCHAR);
if (RootSize + PathSize <= DevicePathSize)
{
memcpy(DevicePathBuf, DeviceRoot, RootSize);
memcpy((PUINT8)DevicePathBuf + RootSize, DevicePath, PathSize);
}
else
/* we should be doing assert(sizeof(WCHAR) <= DevicePathSize), but we don't have assert! */
DevicePathBuf[0] = L'\0';
}
static NTSTATUS CreateSelfRelativeSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,
PSECURITY_DESCRIPTOR *PSelfRelativeSecurityDescriptor, PDWORD PSelfRelativeSecurityDescriptorSize)
{
NTSTATUS Result;
BOOLEAN Success;
PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor = 0;
DWORD SelfRelativeSecurityDescriptorSize;
SECURITY_DESCRIPTOR_CONTROL SecurityDescriptorControl;
DWORD SecurityDescriptorRevision;
SECURITY_DESCRIPTOR SecurityDescriptorStruct;
PTOKEN_USER User = 0;
PACL Acl = 0;
DWORD UserSize = 0;
DWORD AclSize = 0;
HANDLE Token = 0;
*PSelfRelativeSecurityDescriptor = 0;
*PSelfRelativeSecurityDescriptorSize = 0;
if (0 == SecurityDescriptor)
{
Success =
OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &Token) &&
(GetTokenInformation(Token, TokenUser, 0, 0, &UserSize) ||
ERROR_INSUFFICIENT_BUFFER == GetLastError()) &&
(User = MemAllocSLE(UserSize)) &&
GetTokenInformation(Token, TokenUser, User, UserSize, &UserSize) &&
(AclSize = sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(User->User.Sid) - sizeof(DWORD)) &&
(Acl = MemAllocSLE(AclSize)) &&
InitializeAcl(Acl, AclSize, ACL_REVISION) &&
AddAccessAllowedAce(Acl, ACL_REVISION, FILE_ALL_ACCESS, User->User.Sid) &&
InitializeSecurityDescriptor(&SecurityDescriptorStruct, SECURITY_DESCRIPTOR_REVISION) &&
SetSecurityDescriptorDacl(&SecurityDescriptorStruct, TRUE, Acl, FALSE) &&
SetSecurityDescriptorControl(&SecurityDescriptorStruct, SE_DACL_PROTECTED, SE_DACL_PROTECTED);
if (!Success)
{
Result = FspNtStatusFromWin32(GetLastError());
goto exit;
}
SecurityDescriptor = &SecurityDescriptorStruct;
}
if (!GetSecurityDescriptorControl(SecurityDescriptor,
&SecurityDescriptorControl, &SecurityDescriptorRevision))
{
Result = FspNtStatusFromWin32(GetLastError());
goto exit;
}
if (SecurityDescriptorControl & SE_SELF_RELATIVE)
{
SelfRelativeSecurityDescriptorSize = GetSecurityDescriptorLength(SecurityDescriptor);
Success =
(SelfRelativeSecurityDescriptor = MemAllocSLE(SelfRelativeSecurityDescriptorSize)) &&
memcpy(SelfRelativeSecurityDescriptor, SecurityDescriptor, SelfRelativeSecurityDescriptorSize);
}
else
{
SelfRelativeSecurityDescriptorSize = 0;
Success =
(MakeSelfRelativeSD(SecurityDescriptor, 0, &SelfRelativeSecurityDescriptorSize) ||
ERROR_INSUFFICIENT_BUFFER == GetLastError()) &&
(SelfRelativeSecurityDescriptor = MemAllocSLE(SelfRelativeSecurityDescriptorSize)) &&
(MakeSelfRelativeSD(SecurityDescriptor, SelfRelativeSecurityDescriptor, &SelfRelativeSecurityDescriptorSize));
}
if (!Success)
{
Result = FspNtStatusFromWin32(GetLastError());
goto exit;
}
*PSelfRelativeSecurityDescriptor = SelfRelativeSecurityDescriptor;
*PSelfRelativeSecurityDescriptorSize = SelfRelativeSecurityDescriptorSize;
Result = STATUS_SUCCESS;
exit:
if (0 != Token)
CloseHandle(Token);
MemFree(Acl);
MemFree(User);
if (STATUS_SUCCESS != Result)
MemFree(SelfRelativeSecurityDescriptor);
return Result;
}
FSP_API NTSTATUS FspFsctlCreateVolume(PWSTR DevicePath,
const FSP_FSCTL_VOLUME_PARAMS *Params, PSECURITY_DESCRIPTOR SecurityDescriptor,
PWCHAR VolumePathBuf, SIZE_T VolumePathSize)
{
NTSTATUS Result = STATUS_SUCCESS;
PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor = 0;
DWORD SelfRelativeSecurityDescriptorSize;
FSP_FSCTL_VOLUME_PARAMS *ParamsBuf = 0;
WCHAR DevicePathBuf[MAX_PATH];
HANDLE DeviceHandle = INVALID_HANDLE_VALUE;
DWORD Bytes;
if (sizeof(WCHAR) <= VolumePathSize)
VolumePathBuf[0] = L'\0';
Result = CreateSelfRelativeSecurityDescriptor(SecurityDescriptor,
&SelfRelativeSecurityDescriptor, &SelfRelativeSecurityDescriptorSize);
if (!NT_SUCCESS(Result))
goto exit;
ParamsBuf = MemAlloc(FSP_FSCTL_VOLUME_PARAMS_SIZE + SelfRelativeSecurityDescriptorSize);
if (0 == ParamsBuf)
{
Result = STATUS_INSUFFICIENT_RESOURCES;
goto exit;
}
memset(ParamsBuf, 0, FSP_FSCTL_VOLUME_PARAMS_SIZE);
*ParamsBuf = *Params;
memcpy((PUINT8)ParamsBuf + FSP_FSCTL_VOLUME_PARAMS_SIZE,
SelfRelativeSecurityDescriptor, SelfRelativeSecurityDescriptorSize);
GlobalDevicePath(DevicePathBuf, sizeof DevicePathBuf, DevicePath);
#if !defined(NDEBUG)
{
PSTR Sddl;
if (ConvertSecurityDescriptorToStringSecurityDescriptorA(SelfRelativeSecurityDescriptor,
SDDL_REVISION_1,
OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
&Sddl, 0))
{
DEBUGLOG("Device=\"%S\", Sddl=\"%s\", SdSize=%lu",
DevicePathBuf, Sddl, SelfRelativeSecurityDescriptorSize);
LocalFree(Sddl);
}
}
#endif
DeviceHandle = CreateFileW(DevicePathBuf,
0, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
if (INVALID_HANDLE_VALUE == DeviceHandle)
{
Result = FspNtStatusFromWin32(GetLastError());
if (STATUS_OBJECT_NAME_NOT_FOUND == Result)
Result = STATUS_NO_SUCH_DEVICE;
goto exit;
}
if (!DeviceIoControl(DeviceHandle, FSP_FSCTL_CREATE,
ParamsBuf, FSP_FSCTL_VOLUME_PARAMS_SIZE + SelfRelativeSecurityDescriptorSize,
VolumePathBuf, (DWORD)VolumePathSize,
&Bytes, 0))
{
Result = FspNtStatusFromWin32(GetLastError());
goto exit;
}
exit:
if (INVALID_HANDLE_VALUE != DeviceHandle)
CloseHandle(DeviceHandle);
MemFree(ParamsBuf);
MemFree(SelfRelativeSecurityDescriptor);
return Result;
}
FSP_API NTSTATUS FspFsctlOpenVolume(PWSTR VolumePath,
PHANDLE PVolumeHandle)
{
NTSTATUS Result = STATUS_SUCCESS;
WCHAR DevicePathBuf[MAX_PATH];
HANDLE VolumeHandle;
*PVolumeHandle = 0;
GlobalDevicePath(DevicePathBuf, sizeof DevicePathBuf, VolumePath);
DEBUGLOG("Device=\"%S\"", DevicePathBuf);
VolumeHandle = CreateFileW(DevicePathBuf,
0, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
if (INVALID_HANDLE_VALUE == VolumeHandle)
{
Result = FspNtStatusFromWin32(GetLastError());
if (STATUS_OBJECT_NAME_NOT_FOUND == Result)
Result = STATUS_NO_SUCH_DEVICE;
goto exit;
}
*PVolumeHandle = VolumeHandle;
exit:
return Result;
}
FSP_API NTSTATUS FspFsctlDeleteVolume(HANDLE VolumeHandle)
{
NTSTATUS Result = STATUS_SUCCESS;
DWORD Bytes;
if (!DeviceIoControl(VolumeHandle, FSP_FSCTL_DELETE,
0, 0, 0, 0,
&Bytes, 0))
{
Result = FspNtStatusFromWin32(GetLastError());
goto exit;
}
exit:
return Result;
}
FSP_API NTSTATUS FspFsctlTransact(HANDLE VolumeHandle,
PVOID ResponseBuf, SIZE_T ResponseBufSize,
PVOID RequestBuf, SIZE_T *PRequestBufSize)
{
NTSTATUS Result = STATUS_SUCCESS;
DWORD Bytes = 0;
if (0 != PRequestBufSize)
{
Bytes = (DWORD)*PRequestBufSize;
*PRequestBufSize = 0;
}
if (!DeviceIoControl(VolumeHandle, FSP_FSCTL_TRANSACT,
ResponseBuf, (DWORD)ResponseBufSize, RequestBuf, Bytes,
&Bytes, 0))
{
Result = FspNtStatusFromWin32(GetLastError());
goto exit;
}
if (0 != PRequestBufSize)
*PRequestBufSize = Bytes;
exit:
return Result;
}

31
src/dll/library.c
View File

@@ -1,31 +0,0 @@
/**
* @file dll/library.c
*
* @copyright 2015 Bill Zissimopoulos
*/
#include <dll/library.h>
HANDLE ProcessHeap;
BOOL WINAPI DllMain(HINSTANCE Instance, DWORD Reason, PVOID Reserved)
{
switch (Reason)
{
case DLL_PROCESS_ATTACH:
ProcessHeap = GetProcessHeap();
if (0 == ProcessHeap)
return FALSE;
break;
}
return TRUE;
}
/* see comments in library.h */
#if defined(WINFSP_DLL_NODEFAULTLIB)
BOOL WINAPI _DllMainCRTStartup(HINSTANCE Instance, DWORD Reason, PVOID Reserved)
{
return DllMain(Instance, Reason, Reserved);
}
#endif

75
src/dll/library.h
View File

@@ -1,75 +0,0 @@
/**
* @file dll/library.h
*
* @copyright 2015 Bill Zissimopoulos
*/
#ifndef WINFSP_DLL_LIBRARY_H_INCLUDED
#define WINFSP_DLL_LIBRARY_H_INCLUDED
#define WINFSP_DLL_INTERNAL
#include <winfsp/winfsp.h>
#include <strsafe.h>
#define LIBRARY_NAME "WinFsp"
/* DEBUGLOG */
#if !defined(NDEBUG)
#define DEBUGLOG(fmt, ...) \
FspDebugLog("[U] " LIBRARY_NAME "!" __FUNCTION__ ": " fmt "\n", __VA_ARGS__)
#else
#define DEBUGLOG(fmt, ...) ((void)0)
#endif
static inline PVOID MemAlloc(SIZE_T Size)
{
extern HANDLE ProcessHeap;
return HeapAlloc(ProcessHeap, 0, Size);
}
static inline PVOID MemAllocSLE(SIZE_T Size)
{
extern HANDLE ProcessHeap;
PVOID Pointer = HeapAlloc(ProcessHeap, 0, Size);
if (0 == Pointer)
SetLastError(ERROR_NO_SYSTEM_RESOURCES);
return Pointer;
}
static inline VOID MemFree(PVOID Pointer)
{
extern HANDLE ProcessHeap;
if (0 != Pointer)
HeapFree(ProcessHeap, 0, Pointer);
}
/*
* Define WINFSP_DLL_NODEFAULTLIB to eliminate dependency on the MSVCRT libraries.
*
* For this to work the following project settings must be set:
* - "C/C++ > General > SDL checks" must be empty (not "Yes" or "No").
* - "C/C++ > Code Generation > Basic Runtime Checks" must be set to "Default"
* - "C/C++ > Code Generation > Security Check" must be disabled (/GS-).
* - "Linker > Input > Ignore All Default Libraries" must be "Yes".
*/
#if defined(WINFSP_DLL_NODEFAULTLIB)
#undef RtlFillMemory
#undef RtlMoveMemory
NTSYSAPI VOID NTAPI RtlFillMemory(VOID *Destination, DWORD Length, BYTE Fill);
NTSYSAPI VOID NTAPI RtlMoveMemory(VOID *Destination, CONST VOID *Source, DWORD Length);
#pragma function(memcpy)
#pragma function(memset)
static inline
void *memcpy(void *dst, const void *src, size_t siz)
{
RtlMoveMemory(dst, src, (DWORD)siz);
return dst;
}
static inline
void *memset(void *dst, int val, size_t siz)
{
RtlFillMemory(dst, (DWORD)siz, val);
return dst;
}
#endif
#endif

173
src/dll/loop.c
View File

@@ -1,173 +0,0 @@
/**
* @file dll/loop.c
*
* @copyright 2015 Bill Zissimopoulos
*/
#include <dll/library.h>
typedef struct _FSP_WORK_ITEM
{
FSP_FILE_SYSTEM *FileSystem;
__declspec(align(MEMORY_ALLOCATION_ALIGNMENT)) UINT8 RequestBuf[];
} FSP_WORK_ITEM;
FSP_API NTSTATUS FspFileSystemCreate(PWSTR DevicePath,
const FSP_FSCTL_VOLUME_PARAMS *Params, FSP_FILE_SYSTEM_PROCESSREQ *ProcessRequest,
FSP_FILE_SYSTEM **PFileSystem)
{
NTSTATUS Result;
WCHAR VolumePathBuf[MAX_PATH];
HANDLE VolumeHandle = INVALID_HANDLE_VALUE;
FSP_FILE_SYSTEM *FileSystem = 0;
*PFileSystem = 0;
if (0 == ProcessRequest)
ProcessRequest = FspProcessRequestDirect;
FileSystem = MemAlloc(sizeof *FileSystem);
if (0 == FileSystem)
{
Result = STATUS_INSUFFICIENT_RESOURCES;
goto exit;
}
Result = FspFsctlCreateVolume(DevicePath, Params, 0, VolumePathBuf, sizeof VolumePathBuf);
if (!NT_SUCCESS(Result))
goto exit;
Result = FspFsctlOpenVolume(VolumePathBuf, &VolumeHandle);
if (!NT_SUCCESS(Result))
goto exit;
memset(FileSystem, 0, sizeof *FileSystem);
FileSystem->VolumeHandle = VolumeHandle;
FileSystem->ProcessRequest = ProcessRequest;
*PFileSystem = FileSystem;
Result = STATUS_SUCCESS;
exit:
if (!NT_SUCCESS(Result))
{
if (INVALID_HANDLE_VALUE != VolumeHandle)
CloseHandle(VolumeHandle);
MemFree(FileSystem);
}
return Result;
}
FSP_API VOID FspFileSystemDelete(FSP_FILE_SYSTEM *FileSystem)
{
if (INVALID_HANDLE_VALUE != FileSystem->VolumeHandle)
CloseHandle(FileSystem->VolumeHandle);
MemFree(FileSystem);
}
FSP_API NTSTATUS FspFileSystemLoop(FSP_FILE_SYSTEM *FileSystem)
{
NTSTATUS Result;
PUINT8 RequestBuf, RequestBufEnd;
SIZE_T RequestBufSize;
FSP_FSCTL_TRANSACT_REQ *Request, *NextRequest;
RequestBuf = MemAlloc(FSP_FSCTL_TRANSACT_REQ_BUFFER_SIZEMIN);
if (0 == RequestBuf)
return STATUS_INSUFFICIENT_RESOURCES;
for (;;)
{
RequestBufSize = FSP_FSCTL_TRANSACT_REQ_BUFFER_SIZEMIN;
Result = FspFsctlTransact(FileSystem->VolumeHandle, 0, 0, RequestBuf, &RequestBufSize);
if (!NT_SUCCESS(Result))
goto exit;
RequestBufEnd = RequestBuf + RequestBufSize;
Request = (PVOID)RequestBuf;
for (;;)
{
NextRequest = FspFsctlTransactConsumeRequest(Request, RequestBufEnd);
if (0 == NextRequest)
break;
Result = FileSystem->ProcessRequest(FileSystem, Request);
if (!NT_SUCCESS(Result))
goto exit;
Request = NextRequest;
}
}
exit:
MemFree(RequestBuf);
return Result;
}
FSP_API NTSTATUS FspProcessRequestDirect(FSP_FILE_SYSTEM *FileSystem,
FSP_FSCTL_TRANSACT_REQ *Request)
{
if (FspFsctlTransactKindCount <= Request->Kind || 0 == FileSystem->Operations[Request->Kind])
return FspProduceResponseWithStatus(FileSystem, Request, STATUS_INVALID_DEVICE_REQUEST);
FileSystem->Operations[Request->Kind](FileSystem, Request);
return STATUS_SUCCESS;
}
static DWORD WINAPI FspProcessRequestInPoolWorker(PVOID Param)
{
FSP_WORK_ITEM *WorkItem = Param;
FSP_FSCTL_TRANSACT_REQ *Request = (PVOID)WorkItem->RequestBuf;
WorkItem->FileSystem->Operations[Request->Kind](WorkItem->FileSystem, Request);
MemFree(WorkItem);
return 0;
}
FSP_API NTSTATUS FspProcessRequestInPool(FSP_FILE_SYSTEM *FileSystem,
FSP_FSCTL_TRANSACT_REQ *Request)
{
if (FspFsctlTransactKindCount <= Request->Kind || 0 == FileSystem->Operations[Request->Kind])
return FspProduceResponseWithStatus(FileSystem, Request, STATUS_INVALID_DEVICE_REQUEST);
FSP_WORK_ITEM *WorkItem;
BOOLEAN Success;
WorkItem = MemAlloc(sizeof *WorkItem + Request->Size);
if (0 == WorkItem)
return STATUS_INSUFFICIENT_RESOURCES;
WorkItem->FileSystem = FileSystem;
memcpy(WorkItem->RequestBuf, Request, Request->Size);
Success = QueueUserWorkItem(FspProcessRequestInPoolWorker, WorkItem, WT_EXECUTEDEFAULT);
if (!Success)
{
NTSTATUS Result0 = FspNtStatusFromWin32(GetLastError());
MemFree(WorkItem);
return Result0;
}
return STATUS_SUCCESS;
}
FSP_API NTSTATUS FspProduceResponse(FSP_FILE_SYSTEM *FileSystem,
FSP_FSCTL_TRANSACT_RSP *Response)
{
return FspFsctlTransact(FileSystem->VolumeHandle, Response, Response->Size, 0, 0);
}
FSP_API NTSTATUS FspProduceResponseWithStatus(FSP_FILE_SYSTEM *FileSystem,
FSP_FSCTL_TRANSACT_REQ *Request, NTSTATUS Result)
{
FSP_FSCTL_TRANSACT_RSP Response;
memset(&Response, 0, sizeof Response);
Response.Size = sizeof Response;
Response.Kind = Request->Kind;
Response.Hint = Request->Hint;
Response.IoStatus.Status = Result;
return FspProduceResponse(FileSystem, &Response);
}

17
src/dll/ntstatus.c
View File

@@ -1,17 +0,0 @@
/**
* @file dll/ntstatus.c
*
* @copyright 2015 Bill Zissimopoulos
*/
#include <dll/library.h>
FSP_API NTSTATUS FspNtStatusFromWin32(DWORD Error)
{
switch (Error)
{
#include "ntstatus.i"
default:
return STATUS_ACCESS_DENIED;
}
}

621
src/dll/ntstatus.i
View File

@@ -1,621 +0,0 @@
case EPT_S_CANT_CREATE: return EPT_NT_CANT_CREATE;
case EPT_S_CANT_PERFORM_OP: return EPT_NT_CANT_PERFORM_OP;
case EPT_S_INVALID_ENTRY: return EPT_NT_INVALID_ENTRY;
case EPT_S_NOT_REGISTERED: return EPT_NT_NOT_REGISTERED;
case ERROR_ACCESS_DENIED: return STATUS_ACCESS_DENIED;
case ERROR_ACCESS_DISABLED_BY_POLICY: return STATUS_ACCESS_DISABLED_BY_POLICY_OTHER;
case ERROR_ACCOUNT_DISABLED: return STATUS_ACCOUNT_DISABLED;
case ERROR_ACCOUNT_EXPIRED: return STATUS_ACCOUNT_EXPIRED;
case ERROR_ACCOUNT_LOCKED_OUT: return STATUS_ACCOUNT_LOCKED_OUT;
case ERROR_ACCOUNT_RESTRICTION: return STATUS_ACCOUNT_RESTRICTION;
case ERROR_ACTIVE_CONNECTIONS: return STATUS_ALREADY_DISCONNECTED;
case ERROR_ADAP_HDW_ERR: return STATUS_ADAPTER_HARDWARE_ERROR;
case ERROR_ADDRESS_ALREADY_ASSOCIATED: return STATUS_ADDRESS_ALREADY_ASSOCIATED;
case ERROR_ADDRESS_NOT_ASSOCIATED: return STATUS_ADDRESS_NOT_ASSOCIATED;
case ERROR_ALIAS_EXISTS: return STATUS_ALIAS_EXISTS;
case ERROR_ALLOTTED_SPACE_EXCEEDED: return STATUS_ALLOTTED_SPACE_EXCEEDED;
case ERROR_ALREADY_EXISTS: return STATUS_OBJECT_NAME_COLLISION;
case ERROR_ARITHMETIC_OVERFLOW: return STATUS_INTEGER_OVERFLOW;
case ERROR_AUDITING_DISABLED: return STATUS_AUDITING_DISABLED;
case ERROR_BADDB: return STATUS_REGISTRY_CORRUPT;
case ERROR_BAD_COMMAND: return STATUS_INVALID_DEVICE_STATE;
case ERROR_BAD_DESCRIPTOR_FORMAT: return STATUS_BAD_DESCRIPTOR_FORMAT;
case ERROR_BAD_DEV_TYPE: return STATUS_BAD_DEVICE_TYPE;
case ERROR_BAD_DRIVER: return STATUS_DRIVER_UNABLE_TO_LOAD;
case ERROR_BAD_EXE_FORMAT: return STATUS_INVALID_IMAGE_FORMAT;
case ERROR_BAD_IMPERSONATION_LEVEL: return STATUS_BAD_IMPERSONATION_LEVEL;
case ERROR_BAD_INHERITANCE_ACL: return STATUS_BAD_INHERITANCE_ACL;
case ERROR_BAD_LENGTH: return STATUS_INFO_LENGTH_MISMATCH;
case ERROR_BAD_LOGON_SESSION_STATE: return STATUS_BAD_LOGON_SESSION_STATE;
case ERROR_BAD_NETPATH: return STATUS_BAD_NETWORK_PATH;
case ERROR_BAD_NET_NAME: return STATUS_BAD_NETWORK_NAME;
case ERROR_BAD_NET_RESP: return STATUS_INVALID_NETWORK_RESPONSE;
case ERROR_BAD_PATHNAME: return STATUS_OBJECT_PATH_INVALID;
case ERROR_BAD_PIPE: return STATUS_INVALID_PIPE_STATE;
case ERROR_BAD_REM_ADAP: return STATUS_BAD_REMOTE_ADAPTER;
case ERROR_BAD_TOKEN_TYPE: return STATUS_BAD_TOKEN_TYPE;
case ERROR_BAD_VALIDATION_CLASS: return STATUS_BAD_VALIDATION_CLASS;
case ERROR_BEGINNING_OF_MEDIA: return STATUS_BEGINNING_OF_MEDIA;
case ERROR_BROKEN_PIPE: return STATUS_PIPE_BROKEN;
case ERROR_BUSY: return STATUS_DEVICE_BUSY;
case ERROR_BUS_RESET: return STATUS_BUS_RESET;
case ERROR_CANNOT_IMPERSONATE: return STATUS_CANNOT_IMPERSONATE;
case ERROR_CANNOT_MAKE: return STATUS_CANNOT_MAKE;
case ERROR_CANT_ACCESS_DOMAIN_INFO: return STATUS_CANT_ACCESS_DOMAIN_INFO;
case ERROR_CANT_ACCESS_FILE: return STATUS_IO_REPARSE_TAG_NOT_HANDLED;
case ERROR_CANT_DISABLE_MANDATORY: return STATUS_CANT_DISABLE_MANDATORY;
case ERROR_CANT_OPEN_ANONYMOUS: return STATUS_CANT_OPEN_ANONYMOUS;
case ERROR_CANT_RESOLVE_FILENAME: return STATUS_REPARSE_POINT_NOT_RESOLVED;
case ERROR_CHILD_MUST_BE_VOLATILE: return STATUS_CHILD_MUST_BE_VOLATILE;
case ERROR_CLEANER_CARTRIDGE_INSTALLED: return STATUS_CLEANER_CARTRIDGE_INSTALLED;
case ERROR_CLUSTER_INVALID_NETWORK: return STATUS_CLUSTER_INVALID_NETWORK;
case ERROR_CLUSTER_INVALID_NETWORK_PROVIDER: return STATUS_CLUSTER_INVALID_NETWORK_PROVIDER;
case ERROR_CLUSTER_INVALID_NODE: return STATUS_CLUSTER_INVALID_NODE;
case ERROR_CLUSTER_INVALID_REQUEST: return STATUS_CLUSTER_INVALID_REQUEST;
case ERROR_CLUSTER_JOIN_IN_PROGRESS: return STATUS_CLUSTER_JOIN_IN_PROGRESS;
case ERROR_CLUSTER_JOIN_NOT_IN_PROGRESS: return STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS;
case ERROR_CLUSTER_LOCAL_NODE_NOT_FOUND: return STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND;
case ERROR_CLUSTER_NETINTERFACE_EXISTS: return STATUS_CLUSTER_NETINTERFACE_EXISTS;
case ERROR_CLUSTER_NETINTERFACE_NOT_FOUND: return STATUS_CLUSTER_NETINTERFACE_NOT_FOUND;
case ERROR_CLUSTER_NETWORK_ALREADY_OFFLINE: return STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE;
case ERROR_CLUSTER_NETWORK_ALREADY_ONLINE: return STATUS_CLUSTER_NETWORK_ALREADY_ONLINE;
case ERROR_CLUSTER_NETWORK_EXISTS: return STATUS_CLUSTER_NETWORK_EXISTS;
case ERROR_CLUSTER_NETWORK_NOT_FOUND: return STATUS_CLUSTER_NETWORK_NOT_FOUND;
case ERROR_CLUSTER_NETWORK_NOT_INTERNAL: return STATUS_CLUSTER_NETWORK_NOT_INTERNAL;
case ERROR_CLUSTER_NODE_ALREADY_DOWN: return STATUS_CLUSTER_NODE_ALREADY_DOWN;
case ERROR_CLUSTER_NODE_ALREADY_MEMBER: return STATUS_CLUSTER_NODE_ALREADY_MEMBER;
case ERROR_CLUSTER_NODE_ALREADY_UP: return STATUS_CLUSTER_NODE_ALREADY_UP;
case ERROR_CLUSTER_NODE_DOWN: return STATUS_CLUSTER_NODE_DOWN;
case ERROR_CLUSTER_NODE_EXISTS: return STATUS_CLUSTER_NODE_EXISTS;
case ERROR_CLUSTER_NODE_NOT_FOUND: return STATUS_CLUSTER_NODE_NOT_FOUND;
case ERROR_CLUSTER_NODE_NOT_MEMBER: return STATUS_CLUSTER_NODE_NOT_MEMBER;
case ERROR_CLUSTER_NODE_NOT_PAUSED: return STATUS_CLUSTER_NODE_NOT_PAUSED;
case ERROR_CLUSTER_NODE_PAUSED: return STATUS_CLUSTER_NODE_PAUSED;
case ERROR_CLUSTER_NODE_UNREACHABLE: return STATUS_CLUSTER_NODE_UNREACHABLE;
case ERROR_CLUSTER_NODE_UP: return STATUS_CLUSTER_NODE_UP;
case ERROR_CLUSTER_NO_SECURITY_CONTEXT: return STATUS_CLUSTER_NO_SECURITY_CONTEXT;
case ERROR_COMMITMENT_LIMIT: return STATUS_COMMITMENT_LIMIT;
case ERROR_CONNECTION_ABORTED: return STATUS_CONNECTION_ABORTED;
case ERROR_CONNECTION_ACTIVE: return STATUS_CONNECTION_ACTIVE;
case ERROR_CONNECTION_COUNT_LIMIT: return STATUS_CONNECTION_COUNT_LIMIT;
case ERROR_CONNECTION_INVALID: return STATUS_CONNECTION_INVALID;
case ERROR_CONNECTION_REFUSED: return STATUS_CONNECTION_REFUSED;
case ERROR_CONNECTION_UNAVAIL: return STATUS_DFS_UNAVAILABLE;
case ERROR_CONTEXT_EXPIRED: return SEC_E_CONTEXT_EXPIRED;
case ERROR_COUNTER_TIMEOUT: return STATUS_SERIAL_COUNTER_TIMEOUT;
case ERROR_CRC: return STATUS_CRC_ERROR;
case ERROR_CTX_BAD_VIDEO_MODE: return STATUS_CTX_BAD_VIDEO_MODE;
case ERROR_CTX_CLIENT_LICENSE_IN_USE: return STATUS_CTX_CLIENT_LICENSE_IN_USE;
case ERROR_CTX_CLIENT_LICENSE_NOT_SET: return STATUS_CTX_CLIENT_LICENSE_NOT_SET;
case ERROR_CTX_CLIENT_QUERY_TIMEOUT: return STATUS_CTX_CLIENT_QUERY_TIMEOUT;
case ERROR_CTX_CLOSE_PENDING: return STATUS_CTX_CLOSE_PENDING;
case ERROR_CTX_CONSOLE_CONNECT: return STATUS_CTX_CONSOLE_CONNECT;
case ERROR_CTX_CONSOLE_DISCONNECT: return STATUS_CTX_CONSOLE_DISCONNECT;
case ERROR_CTX_GRAPHICS_INVALID: return STATUS_CTX_GRAPHICS_INVALID;
case ERROR_CTX_INVALID_MODEMNAME: return STATUS_CTX_INVALID_MODEMNAME;
case ERROR_CTX_INVALID_PD: return STATUS_CTX_INVALID_PD;
case ERROR_CTX_INVALID_WD: return STATUS_CTX_INVALID_WD;
case ERROR_CTX_LICENSE_CLIENT_INVALID: return STATUS_CTX_LICENSE_CLIENT_INVALID;
case ERROR_CTX_LICENSE_EXPIRED: return STATUS_CTX_LICENSE_EXPIRED;
case ERROR_CTX_LICENSE_NOT_AVAILABLE: return STATUS_CTX_LICENSE_NOT_AVAILABLE;
case ERROR_CTX_MODEM_INF_NOT_FOUND: return STATUS_CTX_MODEM_INF_NOT_FOUND;
case ERROR_CTX_MODEM_RESPONSE_BUSY: return STATUS_CTX_MODEM_RESPONSE_BUSY;
case ERROR_CTX_MODEM_RESPONSE_ERROR: return STATUS_CTX_RESPONSE_ERROR;
case ERROR_CTX_MODEM_RESPONSE_NO_CARRIER: return STATUS_CTX_MODEM_RESPONSE_NO_CARRIER;
case ERROR_CTX_MODEM_RESPONSE_NO_DIALTONE: return STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE;
case ERROR_CTX_MODEM_RESPONSE_TIMEOUT: return STATUS_CTX_MODEM_RESPONSE_TIMEOUT;
case ERROR_CTX_MODEM_RESPONSE_VOICE: return STATUS_CTX_MODEM_RESPONSE_VOICE;
case ERROR_CTX_NOT_CONSOLE: return STATUS_CTX_NOT_CONSOLE;
case ERROR_CTX_NO_OUTBUF: return STATUS_CTX_NO_OUTBUF;
case ERROR_CTX_PD_NOT_FOUND: return STATUS_CTX_PD_NOT_FOUND;
case ERROR_CTX_SHADOW_DENIED: return STATUS_CTX_SHADOW_DENIED;
case ERROR_CTX_SHADOW_DISABLED: return STATUS_CTX_SHADOW_DISABLED;
case ERROR_CTX_SHADOW_ENDED_BY_MODE_CHANGE: return STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE;
case ERROR_CTX_SHADOW_INVALID: return STATUS_CTX_SHADOW_INVALID;
case ERROR_CTX_SHADOW_NOT_RUNNING: return STATUS_CTX_SHADOW_NOT_RUNNING;
case ERROR_CTX_TD_ERROR: return STATUS_CTX_TD_ERROR;
case ERROR_CTX_WD_NOT_FOUND: return STATUS_CTX_WD_NOT_FOUND;
case ERROR_CTX_WINSTATION_ACCESS_DENIED: return STATUS_CTX_WINSTATION_ACCESS_DENIED;
case ERROR_CTX_WINSTATION_ALREADY_EXISTS: return STATUS_CTX_WINSTATION_NAME_COLLISION;
case ERROR_CTX_WINSTATION_BUSY: return STATUS_CTX_WINSTATION_BUSY;
case ERROR_CTX_WINSTATION_NAME_INVALID: return STATUS_CTX_WINSTATION_NAME_INVALID;
case ERROR_CTX_WINSTATION_NOT_FOUND: return STATUS_CTX_WINSTATION_NOT_FOUND;
case ERROR_CURRENT_DOMAIN_NOT_ALLOWED: return STATUS_CURRENT_DOMAIN_NOT_ALLOWED;
case ERROR_DECRYPTION_FAILED: return SEC_E_DECRYPT_FAILURE;
case ERROR_DESTINATION_ELEMENT_FULL: return STATUS_DESTINATION_ELEMENT_FULL;
case ERROR_DEVICE_DOOR_OPEN: return STATUS_DEVICE_DOOR_OPEN;
case ERROR_DEVICE_IN_USE: return STATUS_CONNECTION_IN_USE;
case ERROR_DEVICE_NOT_CONNECTED: return STATUS_DEVICE_NOT_CONNECTED;
case ERROR_DEVICE_NOT_PARTITIONED: return STATUS_DEVICE_NOT_PARTITIONED;
case ERROR_DEVICE_REINITIALIZATION_NEEDED: return STATUS_REINITIALIZATION_NEEDED;
case ERROR_DEVICE_REMOVED: return STATUS_DEVICE_REMOVED;
case ERROR_DEVICE_REQUIRES_CLEANING: return STATUS_DEVICE_REQUIRES_CLEANING;
case ERROR_DEV_NOT_EXIST: return STATUS_DEVICE_DOES_NOT_EXIST;
case ERROR_DIRECTORY: return STATUS_NOT_A_DIRECTORY;
case ERROR_DIR_NOT_EMPTY: return STATUS_DIRECTORY_NOT_EMPTY;
case ERROR_DISK_CORRUPT: return STATUS_DISK_CORRUPT_ERROR;
case ERROR_DISK_FULL: return STATUS_DISK_FULL;
case ERROR_DISK_OPERATION_FAILED: return STATUS_DISK_OPERATION_FAILED;
case ERROR_DISK_RECALIBRATE_FAILED: return STATUS_DISK_RECALIBRATE_FAILED;
case ERROR_DISK_RESET_FAILED: return STATUS_DISK_RESET_FAILED;
case ERROR_DISK_TOO_FRAGMENTED: return STATUS_MFT_TOO_FRAGMENTED;
case ERROR_DLL_INIT_FAILED: return STATUS_DLL_INIT_FAILED;
case ERROR_DOMAIN_CONTROLLER_NOT_FOUND: return STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
case ERROR_DOMAIN_EXISTS: return STATUS_DOMAIN_EXISTS;
case ERROR_DOMAIN_LIMIT_EXCEEDED: return STATUS_DOMAIN_LIMIT_EXCEEDED;
case ERROR_DOMAIN_TRUST_INCONSISTENT: return STATUS_DOMAIN_TRUST_INCONSISTENT;
case ERROR_DOWNGRADE_DETECTED: return STATUS_DOWNGRADE_DETECTED;
case ERROR_DRIVER_BLOCKED: return STATUS_DRIVER_BLOCKED;
case ERROR_DS_ADMIN_LIMIT_EXCEEDED: return STATUS_DS_ADMIN_LIMIT_EXCEEDED;
case ERROR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER: return STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER;
case ERROR_DS_ATTRIBUTE_OR_VALUE_EXISTS: return STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS;
case ERROR_DS_ATTRIBUTE_TYPE_UNDEFINED: return STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED;
case ERROR_DS_BUSY: return STATUS_DS_BUSY;
case ERROR_DS_CANT_MOD_OBJ_CLASS: return STATUS_DS_CANT_MOD_OBJ_CLASS;
case ERROR_DS_CANT_MOD_PRIMARYGROUPID: return STATUS_DS_CANT_MOD_PRIMARYGROUPID;
case ERROR_DS_CANT_ON_NON_LEAF: return STATUS_DS_CANT_ON_NON_LEAF;
case ERROR_DS_CANT_ON_RDN: return STATUS_DS_CANT_ON_RDN;
case ERROR_DS_CANT_START: return STATUS_DS_CANT_START;
case ERROR_DS_CROSS_DOM_MOVE_ERROR: return STATUS_DS_CROSS_DOM_MOVE_FAILED;
case ERROR_DS_DS_REQUIRED: return STATUS_DIRECTORY_SERVICE_REQUIRED;
case ERROR_DS_GC_NOT_AVAILABLE: return STATUS_DS_GC_NOT_AVAILABLE;
case ERROR_DS_GC_REQUIRED: return STATUS_DS_GC_REQUIRED;
case ERROR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER: return STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER;
case ERROR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER: return STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER;
case ERROR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER: return STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER;
case ERROR_DS_HAVE_PRIMARY_MEMBERS: return STATUS_DS_HAVE_PRIMARY_MEMBERS;
case ERROR_DS_INCORRECT_ROLE_OWNER: return STATUS_DS_INCORRECT_ROLE_OWNER;
case ERROR_DS_INIT_FAILURE: return STATUS_DS_INIT_FAILURE;
case ERROR_DS_INIT_FAILURE_CONSOLE: return STATUS_DS_INIT_FAILURE_CONSOLE;
case ERROR_DS_INVALID_ATTRIBUTE_SYNTAX: return STATUS_DS_INVALID_ATTRIBUTE_SYNTAX;
case ERROR_DS_INVALID_GROUP_TYPE: return STATUS_DS_INVALID_GROUP_TYPE;
case ERROR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER: return STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER;
case ERROR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY: return STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY;
case ERROR_DS_MACHINE_ACCOUNT_CREATED_PRENT4: return STATUS_PRENT4_MACHINE_ACCOUNT;
case ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED: return STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED;
case ERROR_DS_MEMBERSHIP_EVALUATED_LOCALLY: return STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY;
case ERROR_DS_NO_ATTRIBUTE_OR_VALUE: return STATUS_DS_NO_ATTRIBUTE_OR_VALUE;
case ERROR_DS_NO_FPO_IN_UNIVERSAL_GROUPS: return STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS;
case ERROR_DS_NO_MORE_RIDS: return STATUS_DS_NO_MORE_RIDS;
case ERROR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN: return STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN;
case ERROR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN: return STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN;
case ERROR_DS_NO_RIDS_ALLOCATED: return STATUS_DS_NO_RIDS_ALLOCATED;
case ERROR_DS_OBJ_CLASS_VIOLATION: return STATUS_DS_OBJ_CLASS_VIOLATION;
case ERROR_DS_RIDMGR_INIT_ERROR: return STATUS_DS_RIDMGR_INIT_ERROR;
case ERROR_DS_SAM_INIT_FAILURE: return STATUS_DS_SAM_INIT_FAILURE;
case ERROR_DS_SAM_INIT_FAILURE_CONSOLE: return STATUS_DS_SAM_INIT_FAILURE_CONSOLE;
case ERROR_DS_SAM_NEED_BOOTKEY_FLOPPY: return STATUS_SAM_NEED_BOOTKEY_FLOPPY;
case ERROR_DS_SAM_NEED_BOOTKEY_PASSWORD: return STATUS_SAM_NEED_BOOTKEY_PASSWORD;
case ERROR_DS_SENSITIVE_GROUP_VIOLATION: return STATUS_DS_SENSITIVE_GROUP_VIOLATION;
case ERROR_DS_SHUTTING_DOWN: return STATUS_DS_SHUTTING_DOWN;
case ERROR_DS_UNAVAILABLE: return STATUS_DS_UNAVAILABLE;
case ERROR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER: return STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER;
case ERROR_DUP_NAME: return STATUS_DUPLICATE_NAME;
case ERROR_EAS_NOT_SUPPORTED: return STATUS_EAS_NOT_SUPPORTED;
case ERROR_EA_LIST_INCONSISTENT: return STATUS_EA_LIST_INCONSISTENT;
case ERROR_EFS_ALG_BLOB_TOO_BIG: return STATUS_EFS_ALG_BLOB_TOO_BIG;
case ERROR_ENCRYPTION_FAILED: return SEC_E_ENCRYPT_FAILURE;
case ERROR_END_OF_MEDIA: return STATUS_END_OF_MEDIA;
case ERROR_ENVVAR_NOT_FOUND: return STATUS_VARIABLE_NOT_FOUND;
case ERROR_EOM_OVERFLOW: return STATUS_EOM_OVERFLOW;
case ERROR_EVENTLOG_CANT_START: return STATUS_EVENTLOG_CANT_START;
case ERROR_EVENTLOG_FILE_CHANGED: return STATUS_EVENTLOG_FILE_CHANGED;
case ERROR_EVENTLOG_FILE_CORRUPT: return STATUS_EVENTLOG_FILE_CORRUPT;
case ERROR_FILEMARK_DETECTED: return STATUS_FILEMARK_DETECTED;
case ERROR_FILENAME_EXCED_RANGE: return STATUS_NAME_TOO_LONG;
case ERROR_FILE_CORRUPT: return STATUS_FILE_CORRUPT_ERROR;
case ERROR_FILE_ENCRYPTED: return STATUS_FILE_ENCRYPTED;
case ERROR_FILE_INVALID: return STATUS_FILE_INVALID;
case ERROR_FILE_NOT_ENCRYPTED: return STATUS_FILE_NOT_ENCRYPTED;
case ERROR_FILE_NOT_FOUND: return STATUS_OBJECT_NAME_NOT_FOUND;
case ERROR_FILE_OFFLINE: return STATUS_FILE_IS_OFFLINE;
case ERROR_FLOPPY_BAD_REGISTERS: return STATUS_FLOPPY_BAD_REGISTERS;
case ERROR_FLOPPY_ID_MARK_NOT_FOUND: return STATUS_FLOPPY_ID_MARK_NOT_FOUND;
case ERROR_FLOPPY_UNKNOWN_ERROR: return STATUS_FLOPPY_UNKNOWN_ERROR;
case ERROR_FLOPPY_WRONG_CYLINDER: return STATUS_FLOPPY_WRONG_CYLINDER;
case ERROR_FULLSCREEN_MODE: return STATUS_FULLSCREEN_MODE;
case ERROR_GENERIC_NOT_MAPPED: return STATUS_GENERIC_NOT_MAPPED;
case ERROR_GEN_FAILURE: return STATUS_UNSUCCESSFUL;
case ERROR_GRACEFUL_DISCONNECT: return STATUS_GRACEFUL_DISCONNECT;
case ERROR_GROUP_EXISTS: return STATUS_GROUP_EXISTS;
case ERROR_HANDLE_EOF: return STATUS_END_OF_FILE;
case ERROR_HOST_DOWN: return STATUS_HOST_DOWN;
case ERROR_HOST_UNREACHABLE: return STATUS_HOST_UNREACHABLE;
case ERROR_ILLEGAL_ELEMENT_ADDRESS: return STATUS_ILLEGAL_ELEMENT_ADDRESS;
case ERROR_ILL_FORMED_PASSWORD: return STATUS_ILL_FORMED_PASSWORD;
case ERROR_INSUFFICIENT_BUFFER: return STATUS_BUFFER_TOO_SMALL;
case ERROR_INTERNAL_DB_CORRUPTION: return STATUS_INTERNAL_DB_CORRUPTION;
case ERROR_INTERNAL_DB_ERROR: return STATUS_INTERNAL_DB_ERROR;
case ERROR_INTERNAL_ERROR: return STATUS_INTERNAL_ERROR;
case ERROR_INVALID_ACCOUNT_NAME: return STATUS_INVALID_ACCOUNT_NAME;
case ERROR_INVALID_ACL: return STATUS_INVALID_ACL;
case ERROR_INVALID_ADDRESS: return STATUS_MEMORY_NOT_ALLOCATED;
case ERROR_INVALID_BLOCK_LENGTH: return STATUS_INVALID_BLOCK_LENGTH;
case ERROR_INVALID_COMPUTERNAME: return STATUS_INVALID_COMPUTER_NAME;
case ERROR_INVALID_DOMAIN_ROLE: return STATUS_INVALID_DOMAIN_ROLE;
case ERROR_INVALID_DOMAIN_STATE: return STATUS_INVALID_DOMAIN_STATE;
case ERROR_INVALID_EA_NAME: return STATUS_INVALID_EA_NAME;
case ERROR_INVALID_FUNCTION: return STATUS_NOT_IMPLEMENTED;
case ERROR_INVALID_GROUP_ATTRIBUTES: return STATUS_INVALID_GROUP_ATTRIBUTES;
case ERROR_INVALID_HANDLE: return STATUS_INVALID_HANDLE;
case ERROR_INVALID_ID_AUTHORITY: return STATUS_INVALID_ID_AUTHORITY;
case ERROR_INVALID_IMPORT_OF_NON_DLL: return STATUS_INVALID_IMPORT_OF_NON_DLL;
case ERROR_INVALID_LEVEL: return STATUS_INVALID_LEVEL;
case ERROR_INVALID_LOGON_HOURS: return STATUS_INVALID_LOGON_HOURS;
case ERROR_INVALID_LOGON_TYPE: return STATUS_INVALID_LOGON_TYPE;
case ERROR_INVALID_MEMBER: return STATUS_INVALID_MEMBER;
case ERROR_INVALID_NAME: return STATUS_OBJECT_NAME_INVALID;
case ERROR_INVALID_NETNAME: return STATUS_INVALID_ADDRESS_COMPONENT;
case ERROR_INVALID_OPLOCK_PROTOCOL: return STATUS_INVALID_OPLOCK_PROTOCOL;
case ERROR_INVALID_ORDINAL: return STATUS_ORDINAL_NOT_FOUND;
case ERROR_INVALID_OWNER: return STATUS_INVALID_OWNER;
case ERROR_INVALID_PARAMETER: return STATUS_INVALID_PARAMETER;
case ERROR_INVALID_PASSWORD: return STATUS_WRONG_PASSWORD;
case ERROR_INVALID_PRIMARY_GROUP: return STATUS_INVALID_PRIMARY_GROUP;
case ERROR_INVALID_REPARSE_DATA: return STATUS_IO_REPARSE_DATA_INVALID;
case ERROR_INVALID_SECURITY_DESCR: return STATUS_INVALID_SECURITY_DESCR;
case ERROR_INVALID_SERVER_STATE: return STATUS_INVALID_SERVER_STATE;
case ERROR_INVALID_SID: return STATUS_INVALID_SID;
case ERROR_INVALID_SUB_AUTHORITY: return STATUS_INVALID_SUB_AUTHORITY;
case ERROR_INVALID_THREAD_ID: return STATUS_NO_LDT;
case ERROR_INVALID_USER_BUFFER: return STATUS_INVALID_USER_BUFFER;
case ERROR_INVALID_WORKSTATION: return STATUS_INVALID_WORKSTATION;
case ERROR_IO_DEVICE: return STATUS_IO_DEVICE_ERROR;
case ERROR_IO_PENDING: return STATUS_PENDING;
case ERROR_IRQ_BUSY: return STATUS_SHARED_IRQ_BUSY;
case ERROR_JOURNAL_DELETE_IN_PROGRESS: return STATUS_JOURNAL_DELETE_IN_PROGRESS;
case ERROR_JOURNAL_ENTRY_DELETED: return STATUS_JOURNAL_ENTRY_DELETED;
case ERROR_JOURNAL_NOT_ACTIVE: return STATUS_JOURNAL_NOT_ACTIVE;
case ERROR_KEY_DELETED: return STATUS_KEY_DELETED;
case ERROR_KEY_HAS_CHILDREN: return STATUS_KEY_HAS_CHILDREN;
case ERROR_LABEL_TOO_LONG: return STATUS_INVALID_VOLUME_LABEL;
case ERROR_LAST_ADMIN: return STATUS_LAST_ADMIN;
case ERROR_LICENSE_QUOTA_EXCEEDED: return STATUS_LICENSE_QUOTA_EXCEEDED;
case ERROR_LM_CROSS_ENCRYPTION_REQUIRED: return STATUS_LM_CROSS_ENCRYPTION_REQUIRED;
case ERROR_LOCAL_USER_SESSION_KEY: return STATUS_LOCAL_USER_SESSION_KEY;
case ERROR_LOCK_VIOLATION: return STATUS_LOCK_NOT_GRANTED;
case ERROR_LOGIN_TIME_RESTRICTION: return STATUS_LOGIN_TIME_RESTRICTION;
case ERROR_LOGIN_WKSTA_RESTRICTION: return STATUS_LOGIN_WKSTA_RESTRICTION;
case ERROR_LOGON_FAILURE: return STATUS_LOGON_FAILURE;
case ERROR_LOGON_NOT_GRANTED: return STATUS_LOGON_NOT_GRANTED;
case ERROR_LOGON_SESSION_COLLISION: return STATUS_LOGON_SESSION_COLLISION;
case ERROR_LOGON_SESSION_EXISTS: return STATUS_LOGON_SESSION_EXISTS;
case ERROR_LOGON_TYPE_NOT_GRANTED: return STATUS_LOGON_TYPE_NOT_GRANTED;
case ERROR_LOG_FILE_FULL: return STATUS_LOG_FILE_FULL;
case ERROR_LUIDS_EXHAUSTED: return STATUS_LUIDS_EXHAUSTED;
case ERROR_MAGAZINE_NOT_PRESENT: return STATUS_MAGAZINE_NOT_PRESENT;
case ERROR_MAPPED_ALIGNMENT: return STATUS_MAPPED_ALIGNMENT;
case ERROR_MEDIA_CHANGED: return STATUS_MEDIA_CHANGED;
case ERROR_MEMBERS_PRIMARY_GROUP: return STATUS_MEMBERS_PRIMARY_GROUP;
case ERROR_MEMBER_IN_ALIAS: return STATUS_MEMBER_IN_ALIAS;
case ERROR_MEMBER_IN_GROUP: return STATUS_MEMBER_IN_GROUP;
case ERROR_MEMBER_NOT_IN_ALIAS: return STATUS_MEMBER_NOT_IN_ALIAS;
case ERROR_MEMBER_NOT_IN_GROUP: return STATUS_MEMBER_NOT_IN_GROUP;
case ERROR_MOD_NOT_FOUND: return STATUS_DLL_NOT_FOUND;
case ERROR_MORE_DATA: return STATUS_BUFFER_OVERFLOW;
case ERROR_MORE_WRITES: return STATUS_SERIAL_MORE_WRITES;
case ERROR_MR_MID_NOT_FOUND: return STATUS_MESSAGE_NOT_FOUND;
case ERROR_MUTUAL_AUTH_FAILED: return STATUS_MUTUAL_AUTHENTICATION_FAILED;
case ERROR_NETLOGON_NOT_STARTED: return STATUS_NETLOGON_NOT_STARTED;
case ERROR_NETNAME_DELETED: return STATUS_NETWORK_NAME_DELETED;
case ERROR_NETWORK_ACCESS_DENIED: return STATUS_NETWORK_ACCESS_DENIED;
case ERROR_NETWORK_BUSY: return STATUS_NETWORK_BUSY;
case ERROR_NETWORK_UNREACHABLE: return STATUS_NETWORK_UNREACHABLE;
case ERROR_NET_WRITE_FAULT: return STATUS_NET_WRITE_FAULT;
case ERROR_NOACCESS: return STATUS_ACCESS_VIOLATION;
case ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT: return STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT;
case ERROR_NOLOGON_SERVER_TRUST_ACCOUNT: return STATUS_NOLOGON_SERVER_TRUST_ACCOUNT;
case ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT: return STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT;
case ERROR_NONE_MAPPED: return STATUS_NONE_MAPPED;
case ERROR_NOTIFY_ENUM_DIR: return STATUS_NOTIFY_ENUM_DIR;
case ERROR_NOT_ALL_ASSIGNED: return STATUS_NOT_ALL_ASSIGNED;
case ERROR_NOT_A_REPARSE_POINT: return STATUS_NOT_A_REPARSE_POINT;
case ERROR_NOT_ENOUGH_MEMORY: return STATUS_NO_MEMORY;
case ERROR_NOT_ENOUGH_QUOTA: return STATUS_QUOTA_EXCEEDED;
case ERROR_NOT_ENOUGH_SERVER_MEMORY: return STATUS_INSUFF_SERVER_RESOURCES;
case ERROR_NOT_EXPORT_FORMAT: return STATUS_NOT_EXPORT_FORMAT;
case ERROR_NOT_FOUND: return STATUS_NOT_FOUND;
case ERROR_NOT_LOCKED: return STATUS_NOT_LOCKED;
case ERROR_NOT_LOGON_PROCESS: return STATUS_NOT_LOGON_PROCESS;
case ERROR_NOT_OWNER: return STATUS_RESOURCE_NOT_OWNED;
case ERROR_NOT_READY: return STATUS_DEVICE_NOT_READY;
case ERROR_NOT_REGISTRY_FILE: return STATUS_NOT_REGISTRY_FILE;
case ERROR_NOT_SAME_DEVICE: return STATUS_NOT_SAME_DEVICE;
case ERROR_NOT_SUPPORTED: return STATUS_NOT_SUPPORTED;
case ERROR_NOT_SUPPORTED_ON_SBS: return STATUS_NOT_SUPPORTED_ON_SBS;
case ERROR_NO_BROWSER_SERVERS_FOUND: return STATUS_NO_BROWSER_SERVERS_FOUND;
case ERROR_NO_DATA: return STATUS_PIPE_EMPTY;
case ERROR_NO_DATA_DETECTED: return STATUS_NO_DATA_DETECTED;
case ERROR_NO_IMPERSONATION_TOKEN: return STATUS_NO_IMPERSONATION_TOKEN;
case ERROR_NO_INHERITANCE: return STATUS_NO_INHERITANCE;
case ERROR_NO_LOGON_SERVERS: return STATUS_NO_LOGON_SERVERS;
case ERROR_NO_LOG_SPACE: return STATUS_NO_LOG_SPACE;
case ERROR_NO_MATCH: return STATUS_NO_MATCH;
case ERROR_NO_MEDIA_IN_DRIVE: return STATUS_NO_MEDIA;
case ERROR_NO_MORE_FILES: return STATUS_NO_MORE_FILES;
case ERROR_NO_MORE_ITEMS: return STATUS_NO_MORE_ENTRIES;
case ERROR_NO_QUOTAS_FOR_ACCOUNT: return STATUS_NO_QUOTAS_FOR_ACCOUNT;
case ERROR_NO_SECURITY_ON_OBJECT: return STATUS_NO_SECURITY_ON_OBJECT;
case ERROR_NO_SPOOL_SPACE: return STATUS_NO_SPOOL_SPACE;
case ERROR_NO_SUCH_ALIAS: return STATUS_NO_SUCH_ALIAS;
case ERROR_NO_SUCH_DOMAIN: return STATUS_NO_SUCH_DOMAIN;
case ERROR_NO_SUCH_GROUP: return STATUS_NO_SUCH_GROUP;
case ERROR_NO_SUCH_LOGON_SESSION: return STATUS_NO_SUCH_LOGON_SESSION;
case ERROR_NO_SUCH_MEMBER: return STATUS_NO_SUCH_MEMBER;
case ERROR_NO_SUCH_PACKAGE: return STATUS_NO_SUCH_PACKAGE;
case ERROR_NO_SUCH_PRIVILEGE: return STATUS_NO_SUCH_PRIVILEGE;
case ERROR_NO_SUCH_USER: return STATUS_NO_SUCH_USER;
case ERROR_NO_SYSTEM_RESOURCES: return STATUS_INSUFFICIENT_RESOURCES;
case ERROR_NO_TOKEN: return STATUS_NO_TOKEN;
case ERROR_NO_TRACKING_SERVICE: return STATUS_NO_TRACKING_SERVICE;
case ERROR_NO_TRUST_LSA_SECRET: return STATUS_NO_TRUST_LSA_SECRET;
case ERROR_NO_TRUST_SAM_ACCOUNT: return STATUS_NO_TRUST_SAM_ACCOUNT;
case ERROR_NO_UNICODE_TRANSLATION: return STATUS_UNMAPPABLE_CHARACTER;
case ERROR_NO_USER_SESSION_KEY: return STATUS_NO_USER_SESSION_KEY;
case ERROR_NT_CROSS_ENCRYPTION_REQUIRED: return STATUS_NT_CROSS_ENCRYPTION_REQUIRED;
case ERROR_NULL_LM_PASSWORD: return STATUS_NULL_LM_PASSWORD;
case ERROR_ONLY_IF_CONNECTED: return STATUS_ONLY_IF_CONNECTED;
case ERROR_OPEN_FILES: return STATUS_FILES_OPEN;
case ERROR_OPERATION_ABORTED: return STATUS_CANCELLED;
case ERROR_OPLOCK_NOT_GRANTED: return STATUS_OPLOCK_NOT_GRANTED;
case ERROR_OUTOFMEMORY: return STATUS_SECTION_NOT_EXTENDED;
case ERROR_OUT_OF_PAPER: return STATUS_DEVICE_PAPER_EMPTY;
case ERROR_PAGEFILE_QUOTA: return STATUS_PAGEFILE_QUOTA;
case ERROR_PARTIAL_COPY: return STATUS_PARTIAL_COPY;
case ERROR_PARTITION_FAILURE: return STATUS_PARTITION_FAILURE;
case ERROR_PASSWORD_EXPIRED: return STATUS_PASSWORD_EXPIRED;
case ERROR_PASSWORD_MUST_CHANGE: return STATUS_PASSWORD_MUST_CHANGE;
case ERROR_PASSWORD_RESTRICTION: return STATUS_PASSWORD_RESTRICTION;
case ERROR_PATH_NOT_FOUND: return STATUS_OBJECT_PATH_NOT_FOUND;
case ERROR_PIPE_BUSY: return STATUS_PIPE_BUSY;
case ERROR_PIPE_CONNECTED: return STATUS_PIPE_CONNECTED;
case ERROR_PIPE_LISTENING: return STATUS_PIPE_LISTENING;
case ERROR_PIPE_NOT_CONNECTED: return STATUS_PIPE_DISCONNECTED;
case ERROR_PKINIT_FAILURE: return STATUS_PKINIT_FAILURE;
case ERROR_POLICY_OBJECT_NOT_FOUND: return STATUS_POLICY_OBJECT_NOT_FOUND;
case ERROR_POLICY_ONLY_IN_DS: return STATUS_POLICY_ONLY_IN_DS;
case ERROR_PORT_UNREACHABLE: return STATUS_PORT_UNREACHABLE;
case ERROR_POSSIBLE_DEADLOCK: return STATUS_POSSIBLE_DEADLOCK;
case ERROR_PRINTQ_FULL: return STATUS_PRINT_QUEUE_FULL;
case ERROR_PRINT_CANCELLED: return STATUS_PRINT_CANCELLED;
case ERROR_PRIVILEGE_NOT_HELD: return STATUS_PRIVILEGE_NOT_HELD;
case ERROR_PROC_NOT_FOUND: return STATUS_PROCEDURE_NOT_FOUND;
case ERROR_PROTOCOL_UNREACHABLE: return STATUS_PROTOCOL_UNREACHABLE;
case ERROR_REDIR_PAUSED: return STATUS_REDIRECTOR_PAUSED;
case ERROR_REGISTRY_IO_FAILED: return STATUS_REGISTRY_IO_FAILED;
case ERROR_REGISTRY_RECOVERED: return STATUS_REGISTRY_RECOVERED;
case ERROR_REG_NAT_CONSUMPTION: return STATUS_REG_NAT_CONSUMPTION;
case ERROR_REMOTE_SESSION_LIMIT_EXCEEDED: return STATUS_REMOTE_SESSION_LIMIT;
case ERROR_REMOTE_STORAGE_MEDIA_ERROR: return STATUS_REMOTE_STORAGE_MEDIA_ERROR;
case ERROR_REMOTE_STORAGE_NOT_ACTIVE: return STATUS_REMOTE_STORAGE_NOT_ACTIVE;
case ERROR_REM_NOT_LIST: return STATUS_REMOTE_NOT_LISTENING;
case ERROR_REPARSE_ATTRIBUTE_CONFLICT: return STATUS_REPARSE_ATTRIBUTE_CONFLICT;
case ERROR_REPARSE_TAG_INVALID: return STATUS_IO_REPARSE_TAG_INVALID;
case ERROR_REPARSE_TAG_MISMATCH: return STATUS_IO_REPARSE_TAG_MISMATCH;
case ERROR_REQUEST_ABORTED: return STATUS_REQUEST_ABORTED;
case ERROR_REQ_NOT_ACCEP: return STATUS_REQUEST_NOT_ACCEPTED;
case ERROR_RESOURCE_DATA_NOT_FOUND: return STATUS_RESOURCE_DATA_NOT_FOUND;
case ERROR_RESOURCE_LANG_NOT_FOUND: return STATUS_RESOURCE_LANG_NOT_FOUND;
case ERROR_RESOURCE_NAME_NOT_FOUND: return STATUS_RESOURCE_NAME_NOT_FOUND;
case ERROR_RESOURCE_TYPE_NOT_FOUND: return STATUS_RESOURCE_TYPE_NOT_FOUND;
case ERROR_RETRY: return STATUS_RETRY;
case ERROR_REVISION_MISMATCH: return STATUS_REVISION_MISMATCH;
case ERROR_RXACT_COMMIT_FAILURE: return STATUS_RXACT_COMMIT_FAILURE;
case ERROR_RXACT_INVALID_STATE: return STATUS_RXACT_INVALID_STATE;
case ERROR_SAM_INIT_FAILURE: return STATUS_SAM_INIT_FAILURE;
case ERROR_SECRET_TOO_LONG: return STATUS_SECRET_TOO_LONG;
case ERROR_SECTOR_NOT_FOUND: return STATUS_NONEXISTENT_SECTOR;
case ERROR_SEM_TIMEOUT: return STATUS_IO_TIMEOUT;
case ERROR_SERIAL_NO_DEVICE: return STATUS_SERIAL_NO_DEVICE_INITED;
case ERROR_SERVER_DISABLED: return STATUS_SERVER_DISABLED;
case ERROR_SERVER_NOT_DISABLED: return STATUS_SERVER_NOT_DISABLED;
case ERROR_SERVER_SHUTDOWN_IN_PROGRESS: return STATUS_SERVER_SHUTDOWN_IN_PROGRESS;
case ERROR_SERVICE_ALREADY_RUNNING: return STATUS_IMAGE_ALREADY_LOADED;
case ERROR_SERVICE_DISABLED: return STATUS_PLUGPLAY_NO_DEVICE;
case ERROR_SESSION_CREDENTIAL_CONFLICT: return STATUS_NETWORK_CREDENTIAL_CONFLICT;
case ERROR_SETMARK_DETECTED: return STATUS_SETMARK_DETECTED;
case ERROR_SET_NOT_FOUND: return STATUS_PROPSET_NOT_FOUND;
case ERROR_SHARED_POLICY: return STATUS_SHARED_POLICY;
case ERROR_SHARING_PAUSED: return STATUS_SHARING_PAUSED;
case ERROR_SHARING_VIOLATION: return STATUS_SHARING_VIOLATION;
case ERROR_SHUTDOWN_IN_PROGRESS: return STATUS_SHUTDOWN_IN_PROGRESS;
case ERROR_SIGNAL_REFUSED: return STATUS_SUSPEND_COUNT_EXCEEDED;
case ERROR_SMARTCARD_SUBSYSTEM_FAILURE: return STATUS_SMARTCARD_SUBSYSTEM_FAILURE;
case ERROR_SOME_NOT_MAPPED: return STATUS_SOME_NOT_MAPPED;
case ERROR_SOURCE_ELEMENT_EMPTY: return STATUS_SOURCE_ELEMENT_EMPTY;
case ERROR_SPECIAL_ACCOUNT: return STATUS_SPECIAL_ACCOUNT;
case ERROR_SPECIAL_GROUP: return STATUS_SPECIAL_GROUP;
case ERROR_SPECIAL_USER: return STATUS_SPECIAL_USER;
case ERROR_STACK_OVERFLOW: return STATUS_STACK_OVERFLOW;
case ERROR_SWAPERROR: return STATUS_IN_PAGE_ERROR;
case ERROR_SXS_ACTIVATION_CONTEXT_DISABLED: return STATUS_SXS_ACTIVATION_CONTEXT_DISABLED;
case ERROR_SXS_ASSEMBLY_NOT_FOUND: return STATUS_SXS_ASSEMBLY_NOT_FOUND;
case ERROR_SXS_CANT_GEN_ACTCTX: return STATUS_SXS_CANT_GEN_ACTCTX;
case ERROR_SXS_INVALID_ACTCTXDATA_FORMAT: return STATUS_SXS_INVALID_ACTCTXDATA_FORMAT;
case ERROR_SXS_KEY_NOT_FOUND: return STATUS_SXS_KEY_NOT_FOUND;
case ERROR_SXS_MANIFEST_FORMAT_ERROR: return STATUS_SXS_MANIFEST_FORMAT_ERROR;
case ERROR_SXS_MANIFEST_PARSE_ERROR: return STATUS_SXS_MANIFEST_PARSE_ERROR;
case ERROR_SXS_PROCESS_DEFAULT_ALREADY_SET: return STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET;
case ERROR_SXS_SECTION_NOT_FOUND: return STATUS_SXS_SECTION_NOT_FOUND;
case ERROR_SXS_THREAD_QUERIES_DISABLED: return STATUS_SXS_THREAD_QUERIES_DISABLED;
case ERROR_SXS_WRONG_SECTION_TYPE: return STATUS_SXS_WRONG_SECTION_TYPE;
case ERROR_TIME_SKEW: return STATUS_TIME_DIFFERENCE_AT_DC;
case ERROR_TOKEN_ALREADY_IN_USE: return STATUS_TOKEN_ALREADY_IN_USE;
case ERROR_TOO_MANY_CMDS: return STATUS_TOO_MANY_COMMANDS;
case ERROR_TOO_MANY_CONTEXT_IDS: return STATUS_TOO_MANY_CONTEXT_IDS;
case ERROR_TOO_MANY_LINKS: return STATUS_TOO_MANY_LINKS;
case ERROR_TOO_MANY_LUIDS_REQUESTED: return STATUS_TOO_MANY_LUIDS_REQUESTED;
case ERROR_TOO_MANY_NAMES: return STATUS_TOO_MANY_NAMES;
case ERROR_TOO_MANY_OPEN_FILES: return STATUS_TOO_MANY_OPENED_FILES;
case ERROR_TOO_MANY_POSTS: return STATUS_SEMAPHORE_LIMIT_EXCEEDED;
case ERROR_TOO_MANY_SECRETS: return STATUS_TOO_MANY_SECRETS;
case ERROR_TOO_MANY_SESS: return STATUS_TOO_MANY_SESSIONS;
case ERROR_TOO_MANY_SIDS: return STATUS_TOO_MANY_SIDS;
case ERROR_TRANSPORT_FULL: return STATUS_TRANSPORT_FULL;
case ERROR_TRUSTED_DOMAIN_FAILURE: return STATUS_TRUSTED_DOMAIN_FAILURE;
case ERROR_TRUSTED_RELATIONSHIP_FAILURE: return STATUS_TRUSTED_RELATIONSHIP_FAILURE;
case ERROR_TRUST_FAILURE: return STATUS_TRUST_FAILURE;
case ERROR_UNABLE_TO_LOCK_MEDIA: return STATUS_UNABLE_TO_LOCK_MEDIA;
case ERROR_UNABLE_TO_UNLOAD_MEDIA: return STATUS_UNABLE_TO_UNLOAD_MEDIA;
case ERROR_UNEXP_NET_ERR: return STATUS_UNEXPECTED_NETWORK_ERROR;
case ERROR_UNKNOWN_REVISION: return STATUS_UNKNOWN_REVISION;
case ERROR_UNRECOGNIZED_MEDIA: return STATUS_UNRECOGNIZED_MEDIA;
case ERROR_UNRECOGNIZED_VOLUME: return STATUS_UNRECOGNIZED_VOLUME;
case ERROR_USER_EXISTS: return STATUS_USER_EXISTS;
case ERROR_USER_MAPPED_FILE: return STATUS_USER_MAPPED_FILE;
case ERROR_VC_DISCONNECTED: return STATUS_VIRTUAL_CIRCUIT_CLOSED;
case ERROR_WMI_ALREADY_DISABLED: return STATUS_WMI_ALREADY_DISABLED;
case ERROR_WMI_ALREADY_ENABLED: return STATUS_WMI_ALREADY_ENABLED;
case ERROR_WMI_GUID_DISCONNECTED: return STATUS_WMI_GUID_DISCONNECTED;
case ERROR_WMI_GUID_NOT_FOUND: return STATUS_WMI_GUID_NOT_FOUND;
case ERROR_WMI_INSTANCE_NOT_FOUND: return STATUS_WMI_INSTANCE_NOT_FOUND;
case ERROR_WMI_ITEMID_NOT_FOUND: return STATUS_WMI_ITEMID_NOT_FOUND;
case ERROR_WMI_READ_ONLY: return STATUS_WMI_READ_ONLY;
case ERROR_WMI_SET_FAILURE: return STATUS_WMI_SET_FAILURE;
case ERROR_WMI_TRY_AGAIN: return STATUS_WMI_TRY_AGAIN;
case ERROR_WORKING_SET_QUOTA: return STATUS_WORKING_SET_QUOTA;
case ERROR_WRITE_PROTECT: return STATUS_MEDIA_WRITE_PROTECTED;
case ERROR_WRONG_DISK: return STATUS_WRONG_VOLUME;
case ERROR_WRONG_TARGET_NAME: return SEC_E_WRONG_PRINCIPAL;
case NO_ERROR: return STATUS_SUCCESS;
case NTE_BAD_KEYSET: return STATUS_SMARTCARD_NO_KEYSET;
case NTE_NO_KEY: return STATUS_SMARTCARD_NO_KEY_CONTAINER;
case RPC_S_ADDRESS_ERROR: return RPC_NT_ADDRESS_ERROR;
case RPC_S_ALREADY_LISTENING: return RPC_NT_ALREADY_LISTENING;
case RPC_S_ALREADY_REGISTERED: return RPC_NT_ALREADY_REGISTERED;
case RPC_S_BINDING_HAS_NO_AUTH: return RPC_NT_BINDING_HAS_NO_AUTH;
case RPC_S_BINDING_INCOMPLETE: return RPC_NT_BINDING_INCOMPLETE;
case RPC_S_CALL_CANCELLED: return RPC_NT_CALL_CANCELLED;
case RPC_S_CALL_FAILED: return RPC_NT_CALL_FAILED;
case RPC_S_CALL_FAILED_DNE: return RPC_NT_CALL_FAILED_DNE;
case RPC_S_CALL_IN_PROGRESS: return RPC_NT_CALL_IN_PROGRESS;
case RPC_S_CANNOT_SUPPORT: return RPC_NT_CANNOT_SUPPORT;
case RPC_S_CANT_CREATE_ENDPOINT: return RPC_NT_CANT_CREATE_ENDPOINT;
case RPC_S_COMM_FAILURE: return RPC_NT_COMM_FAILURE;
case RPC_S_DUPLICATE_ENDPOINT: return RPC_NT_DUPLICATE_ENDPOINT;
case RPC_S_ENTRY_ALREADY_EXISTS: return RPC_NT_ENTRY_ALREADY_EXISTS;
case RPC_S_ENTRY_NOT_FOUND: return RPC_NT_ENTRY_NOT_FOUND;
case RPC_S_FP_DIV_ZERO: return RPC_NT_FP_DIV_ZERO;
case RPC_S_FP_OVERFLOW: return RPC_NT_FP_OVERFLOW;
case RPC_S_FP_UNDERFLOW: return RPC_NT_FP_UNDERFLOW;
case RPC_S_GROUP_MEMBER_NOT_FOUND: return RPC_NT_GROUP_MEMBER_NOT_FOUND;
case RPC_S_INCOMPLETE_NAME: return RPC_NT_INCOMPLETE_NAME;
case RPC_S_INTERFACE_NOT_FOUND: return RPC_NT_INTERFACE_NOT_FOUND;
case RPC_S_INTERNAL_ERROR: return RPC_NT_INTERNAL_ERROR;
case RPC_S_INVALID_ASYNC_CALL: return RPC_NT_INVALID_ASYNC_CALL;
case RPC_S_INVALID_ASYNC_HANDLE: return RPC_NT_INVALID_ASYNC_HANDLE;
case RPC_S_INVALID_AUTH_IDENTITY: return RPC_NT_INVALID_AUTH_IDENTITY;
case RPC_S_INVALID_BOUND: return RPC_NT_INVALID_BOUND;
case RPC_S_INVALID_ENDPOINT_FORMAT: return RPC_NT_INVALID_ENDPOINT_FORMAT;
case RPC_S_INVALID_NAF_ID: return RPC_NT_INVALID_NAF_ID;
case RPC_S_INVALID_NAME_SYNTAX: return RPC_NT_INVALID_NAME_SYNTAX;
case RPC_S_INVALID_NETWORK_OPTIONS: return RPC_NT_INVALID_NETWORK_OPTIONS;
case RPC_S_INVALID_NET_ADDR: return RPC_NT_INVALID_NET_ADDR;
case RPC_S_INVALID_OBJECT: return RPC_NT_INVALID_OBJECT;
case RPC_S_INVALID_RPC_PROTSEQ: return RPC_NT_INVALID_RPC_PROTSEQ;
case RPC_S_INVALID_STRING_BINDING: return RPC_NT_INVALID_STRING_BINDING;
case RPC_S_INVALID_STRING_UUID: return RPC_NT_INVALID_STRING_UUID;
case RPC_S_INVALID_TAG: return RPC_NT_INVALID_TAG;
case RPC_S_INVALID_TIMEOUT: return RPC_NT_INVALID_TIMEOUT;
case RPC_S_INVALID_VERS_OPTION: return RPC_NT_INVALID_VERS_OPTION;
case RPC_S_MAX_CALLS_TOO_SMALL: return RPC_NT_MAX_CALLS_TOO_SMALL;
case RPC_S_NAME_SERVICE_UNAVAILABLE: return RPC_NT_NAME_SERVICE_UNAVAILABLE;
case RPC_S_NOTHING_TO_EXPORT: return RPC_NT_NOTHING_TO_EXPORT;
case RPC_S_NOT_ALL_OBJS_UNEXPORTED: return RPC_NT_NOT_ALL_OBJS_UNEXPORTED;
case RPC_S_NOT_CANCELLED: return RPC_NT_NOT_CANCELLED;
case RPC_S_NOT_LISTENING: return RPC_NT_NOT_LISTENING;
case RPC_S_NOT_RPC_ERROR: return RPC_NT_NOT_RPC_ERROR;
case RPC_S_NO_BINDINGS: return RPC_NT_NO_BINDINGS;
case RPC_S_NO_CALL_ACTIVE: return RPC_NT_NO_CALL_ACTIVE;
case RPC_S_NO_CONTEXT_AVAILABLE: return RPC_NT_NO_CONTEXT_AVAILABLE;
case RPC_S_NO_ENDPOINT_FOUND: return RPC_NT_NO_ENDPOINT_FOUND;
case RPC_S_NO_ENTRY_NAME: return RPC_NT_NO_ENTRY_NAME;
case RPC_S_NO_INTERFACES: return RPC_NT_NO_INTERFACES;
case RPC_S_NO_MORE_BINDINGS: return RPC_NT_NO_MORE_BINDINGS;
case RPC_S_NO_MORE_MEMBERS: return RPC_NT_NO_MORE_MEMBERS;
case RPC_S_NO_PRINC_NAME: return RPC_NT_NO_PRINC_NAME;
case RPC_S_NO_PROTSEQS: return RPC_NT_NO_PROTSEQS;
case RPC_S_NO_PROTSEQS_REGISTERED: return RPC_NT_NO_PROTSEQS_REGISTERED;
case RPC_S_OBJECT_NOT_FOUND: return RPC_NT_OBJECT_NOT_FOUND;
case RPC_S_OUT_OF_RESOURCES: return RPC_NT_OUT_OF_RESOURCES;
case RPC_S_PROCNUM_OUT_OF_RANGE: return RPC_NT_PROCNUM_OUT_OF_RANGE;
case RPC_S_PROTOCOL_ERROR: return RPC_NT_PROTOCOL_ERROR;
case RPC_S_PROTSEQ_NOT_FOUND: return RPC_NT_PROTSEQ_NOT_FOUND;
case RPC_S_PROTSEQ_NOT_SUPPORTED: return RPC_NT_PROTSEQ_NOT_SUPPORTED;
case RPC_S_SEC_PKG_ERROR: return RPC_NT_SEC_PKG_ERROR;
case RPC_S_SEND_INCOMPLETE: return RPC_NT_SEND_INCOMPLETE;
case RPC_S_SERVER_TOO_BUSY: return RPC_NT_SERVER_TOO_BUSY;
case RPC_S_SERVER_UNAVAILABLE: return RPC_NT_SERVER_UNAVAILABLE;
case RPC_S_STRING_TOO_LONG: return RPC_NT_STRING_TOO_LONG;
case RPC_S_TYPE_ALREADY_REGISTERED: return RPC_NT_TYPE_ALREADY_REGISTERED;
case RPC_S_UNKNOWN_AUTHN_LEVEL: return RPC_NT_UNKNOWN_AUTHN_LEVEL;
case RPC_S_UNKNOWN_AUTHN_SERVICE: return RPC_NT_UNKNOWN_AUTHN_SERVICE;
case RPC_S_UNKNOWN_AUTHN_TYPE: return RPC_NT_UNKNOWN_AUTHN_TYPE;
case RPC_S_UNKNOWN_AUTHZ_SERVICE: return RPC_NT_UNKNOWN_AUTHZ_SERVICE;
case RPC_S_UNKNOWN_IF: return RPC_NT_UNKNOWN_IF;
case RPC_S_UNKNOWN_MGR_TYPE: return RPC_NT_UNKNOWN_MGR_TYPE;
case RPC_S_UNSUPPORTED_AUTHN_LEVEL: return RPC_NT_UNSUPPORTED_AUTHN_LEVEL;
case RPC_S_UNSUPPORTED_NAME_SYNTAX: return RPC_NT_UNSUPPORTED_NAME_SYNTAX;
case RPC_S_UNSUPPORTED_TRANS_SYN: return RPC_NT_UNSUPPORTED_TRANS_SYN;
case RPC_S_UNSUPPORTED_TYPE: return RPC_NT_UNSUPPORTED_TYPE;
case RPC_S_UUID_LOCAL_ONLY: return RPC_NT_UUID_LOCAL_ONLY;
case RPC_S_UUID_NO_ADDRESS: return RPC_NT_UUID_NO_ADDRESS;
case RPC_S_WRONG_KIND_OF_BINDING: return RPC_NT_WRONG_KIND_OF_BINDING;
case RPC_S_ZERO_DIVIDE: return RPC_NT_ZERO_DIVIDE;
case RPC_X_BAD_STUB_DATA: return RPC_NT_BAD_STUB_DATA;
case RPC_X_BYTE_COUNT_TOO_SMALL: return RPC_NT_BYTE_COUNT_TOO_SMALL;
case RPC_X_ENUM_VALUE_OUT_OF_RANGE: return RPC_NT_ENUM_VALUE_OUT_OF_RANGE;
case RPC_X_INVALID_ES_ACTION: return RPC_NT_INVALID_ES_ACTION;
case RPC_X_INVALID_PIPE_OBJECT: return RPC_NT_INVALID_PIPE_OBJECT;
case RPC_X_INVALID_PIPE_OPERATION: return RPC_NT_INVALID_PIPE_OPERATION;
case RPC_X_NO_MORE_ENTRIES: return RPC_NT_NO_MORE_ENTRIES;
case RPC_X_NULL_REF_POINTER: return RPC_NT_NULL_REF_POINTER;
case RPC_X_PIPE_CLOSED: return RPC_NT_PIPE_CLOSED;
case RPC_X_PIPE_DISCIPLINE_ERROR: return RPC_NT_PIPE_DISCIPLINE_ERROR;
case RPC_X_PIPE_EMPTY: return RPC_NT_PIPE_EMPTY;
case RPC_X_SS_CANNOT_GET_CALL_HANDLE: return RPC_NT_SS_CANNOT_GET_CALL_HANDLE;
case RPC_X_SS_CHAR_TRANS_OPEN_FAIL: return RPC_NT_SS_CHAR_TRANS_OPEN_FAIL;
case RPC_X_SS_CHAR_TRANS_SHORT_FILE: return RPC_NT_SS_CHAR_TRANS_SHORT_FILE;
case RPC_X_SS_CONTEXT_DAMAGED: return RPC_NT_SS_CONTEXT_DAMAGED;
case RPC_X_SS_HANDLES_MISMATCH: return RPC_NT_SS_HANDLES_MISMATCH;
case RPC_X_WRONG_ES_VERSION: return RPC_NT_WRONG_ES_VERSION;
case RPC_X_WRONG_PIPE_VERSION: return RPC_NT_WRONG_PIPE_VERSION;
case RPC_X_WRONG_STUB_VERSION: return RPC_NT_WRONG_STUB_VERSION;
case SCARD_E_COMM_DATA_LOST: return STATUS_SMARTCARD_IO_ERROR;
case SCARD_E_NO_SMARTCARD: return STATUS_SMARTCARD_NO_CARD;
case SCARD_E_NO_SUCH_CERTIFICATE: return STATUS_SMARTCARD_NO_CERTIFICATE;
case SCARD_W_CARD_NOT_AUTHENTICATED: return STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED;
case SCARD_W_CHV_BLOCKED: return STATUS_SMARTCARD_CARD_BLOCKED;
case SCARD_W_WRONG_CHV: return STATUS_SMARTCARD_WRONG_PIN;
case SEC_E_BAD_BINDINGS: return STATUS_BAD_BINDINGS;
case SEC_E_CRYPTO_SYSTEM_INVALID: return STATUS_CRYPTO_SYSTEM_INVALID;
case SEC_E_ISSUING_CA_UNTRUSTED: return STATUS_ISSUING_CA_UNTRUSTED;
case SEC_E_KDC_INVALID_REQUEST: return STATUS_KDC_INVALID_REQUEST;
case SEC_E_KDC_UNABLE_TO_REFER: return STATUS_KDC_UNABLE_TO_REFER;
case SEC_E_KDC_UNKNOWN_ETYPE: return STATUS_KDC_UNKNOWN_ETYPE;
case SEC_E_MAX_REFERRALS_EXCEEDED: return STATUS_MAX_REFERRALS_EXCEEDED;
case SEC_E_MUST_BE_KDC: return STATUS_MUST_BE_KDC;
case SEC_E_NO_IP_ADDRESSES: return STATUS_NO_IP_ADDRESSES;
case SEC_E_NO_KERB_KEY: return STATUS_NO_KERB_KEY;
case SEC_E_NO_PA_DATA: return STATUS_NO_PA_DATA;
case SEC_E_NO_TGT_REPLY: return STATUS_NO_TGT_REPLY;
case SEC_E_PKINIT_CLIENT_FAILURE: return STATUS_PKINIT_CLIENT_FAILURE;
case SEC_E_PKINIT_NAME_MISMATCH: return STATUS_PKINIT_NAME_MISMATCH;
case SEC_E_REVOCATION_OFFLINE_C: return STATUS_REVOCATION_OFFLINE_C;
case SEC_E_SMARTCARD_CERT_EXPIRED: return STATUS_SMARTCARD_CERT_EXPIRED;
case SEC_E_SMARTCARD_CERT_REVOKED: return STATUS_SMARTCARD_CERT_REVOKED;
case SEC_E_SMARTCARD_LOGON_REQUIRED: return STATUS_SMARTCARD_LOGON_REQUIRED;
case SEC_E_STRONG_CRYPTO_NOT_SUPPORTED: return STATUS_STRONG_CRYPTO_NOT_SUPPORTED;
case SEC_E_TOO_MANY_PRINCIPALS: return STATUS_TOO_MANY_PRINCIPALS;
case SEC_E_UNFINISHED_CONTEXT_DELETED: return STATUS_UNFINISHED_CONTEXT_DELETED;
case SEC_E_UNSUPPORTED_PREAUTH: return STATUS_UNSUPPORTED_PREAUTH;
case SEC_E_WRONG_CREDENTIAL_HANDLE: return STATUS_WRONG_CREDENTIAL_HANDLE;
case STATUS_DUPLICATE_OBJECTID: return STATUS_DUPLICATE_OBJECTID;
case STATUS_OBJECTID_EXISTS: return STATUS_OBJECTID_EXISTS;
case STG_E_CSS_AUTHENTICATION_FAILURE: return STATUS_CSS_AUTHENTICATION_FAILURE;
case STG_E_CSS_KEY_NOT_ESTABLISHED: return STATUS_CSS_KEY_NOT_ESTABLISHED;
case STG_E_CSS_KEY_NOT_PRESENT: return STATUS_CSS_KEY_NOT_PRESENT;
case STG_E_CSS_REGION_MISMATCH: return STATUS_CSS_REGION_MISMATCH;
case STG_E_CSS_SCRAMBLED_SECTOR: return STATUS_CSS_SCRAMBLED_SECTOR;
case STG_E_RESETS_EXHAUSTED: return STATUS_CSS_RESETS_EXHAUSTED;
case STG_E_STATUS_COPY_PROTECTION_FAILURE: return STATUS_COPY_PROTECTION_FAILURE;

109
src/sys/cleanup.c
View File

@@ -23,14 +23,18 @@ FSP_DRIVER_DISPATCH FspCleanup;
#pragma alloc_text(PAGE, FspCleanup)
#endif
VOID FspFsctlDeleteVolume(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
static NTSTATUS FspFsctlCleanup(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
PAGED_CODE();
NTSTATUS Result = STATUS_SUCCESS;
FspFsctlDeleteVolume(DeviceObject, Irp, IrpSp);
Irp->IoStatus.Information = 0;
return Result;
return STATUS_SUCCESS;
}
static NTSTATUS FspFsvrtCleanup(
@@ -38,9 +42,8 @@ static NTSTATUS FspFsvrtCleanup(
{
PAGED_CODE();
NTSTATUS Result = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
return Result;
return STATUS_SUCCESS;
}
static NTSTATUS FspFsvolCleanup(
@@ -48,101 +51,7 @@ static NTSTATUS FspFsvolCleanup(
{
PAGED_CODE();
/* is this a valid FileObject? */
if (!FspFileContextIsValid(IrpSp->FileObject->FsContext))
return STATUS_SUCCESS;
NTSTATUS Result;
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
PFILE_OBJECT FileObject = IrpSp->FileObject;
FSP_FILE_CONTEXT *FsContext = FileObject->FsContext;
UINT64 UserContext = FsContext->UserContext;
UINT64 UserContext2 = (UINT_PTR)FileObject->FsContext2;
BOOLEAN DeletePending;
LONG OpenCount;
/* lock the FsContext */
ExAcquireResourceExclusiveLite(FsContext->Header.Resource, TRUE);
/* propagate the FsContext DeleteOnClose to DeletePending */
if (FsContext->DeleteOnClose)
FsContext->DeletePending = TRUE;
DeletePending = FsContext->DeletePending;
/* all handles on this FileObject are gone; decrement its FsContext->OpenCount */
OpenCount = FspFileContextClose(FsContext);
/* unlock the FsContext */
ExReleaseResourceLite(FsContext->Header.Resource);
/* is the FsContext going away as well? */
if (0 == OpenCount)
{
/*
* The following must be done under the file system volume device Resource,
* because we are manipulating its GenericTable.
*/
ExAcquireResourceExclusiveLite(&FsvolDeviceExtension->Base.Resource, TRUE);
try
{
/* remove the FsContext from the file system volume device generic table */
FspFsvolDeviceDeleteContext(DeviceObject, FsContext->UserContext, 0);
}
finally
{
ExReleaseResourceLite(&FsvolDeviceExtension->Base.Resource);
}
}
PDEVICE_OBJECT FsvrtDeviceObject = FsvolDeviceExtension->FsvrtDeviceObject;
if (!FspDeviceRetain(FsvrtDeviceObject))
/* IRP_MJ_CLEANUP cannot really fail :-\ */
return STATUS_SUCCESS;
try
{
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(FsvrtDeviceObject);
BOOLEAN FileNameRequired = 0 != FsvrtDeviceExtension->VolumeParams.FileNameRequired;
FSP_FSCTL_TRANSACT_REQ *Request;
/* create the user-mode file system request */
Result = FspIopCreateRequest(Irp, FileNameRequired ? &FsContext->FileName : 0, 0, &Request);
if (!NT_SUCCESS(Result))
goto leak_exit;
/*
* The new request is associated with our IRP and will be deleted during its completion.
*/
/* populate the Cleanup request */
Request->Kind = FspFsctlTransactCleanupKind;
Request->Req.Cleanup.UserContext = UserContext;
Request->Req.Cleanup.UserContext2 = UserContext2;
Request->Req.Cleanup.Delete = DeletePending && 0 == OpenCount;
Result = STATUS_PENDING;
goto exit;
leak_exit:;
#if DBG
DEBUGLOG("FileObject=%p[%p:\"%wZ\"], UserContext=%llx, UserContext2=%llx: "
"error: the user-mode file system handle will be leaked!",
IrpSp->FileObject, IrpSp->FileObject->RelatedFileObject, IrpSp->FileObject->FileName,
UserContext, UserContext2);
#endif
/* IRP_MJ_CLEANUP cannot really fail :-\ */
Result = STATUS_SUCCESS;
exit:;
}
finally
{
FspDeviceRelease(FsvrtDeviceObject);
}
return Result;
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolCleanupComplete(
@@ -158,8 +67,6 @@ NTSTATUS FspCleanup(
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_CLEANUP == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:

76
src/sys/close.c
View File

@@ -28,9 +28,8 @@ static NTSTATUS FspFsctlClose(
{
PAGED_CODE();
NTSTATUS Result = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
return Result;
return STATUS_SUCCESS;
}
static NTSTATUS FspFsvrtClose(
@@ -38,9 +37,8 @@ static NTSTATUS FspFsvrtClose(
{
PAGED_CODE();
NTSTATUS Result = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
return Result;
return STATUS_SUCCESS;
}
static NTSTATUS FspFsvolClose(
@@ -48,73 +46,7 @@ static NTSTATUS FspFsvolClose(
{
PAGED_CODE();
/* is this a valid FileObject? */
if (!FspFileContextIsValid(IrpSp->FileObject->FsContext))
return STATUS_SUCCESS;
NTSTATUS Result;
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
PFILE_OBJECT FileObject = IrpSp->FileObject;
FSP_FILE_CONTEXT *FsContext = FileObject->FsContext;
UINT64 UserContext = FsContext->UserContext;
UINT64 UserContext2 = (UINT_PTR)FileObject->FsContext2;
/* dereference the FsContext (and delete if no more references) */
FspFileContextRelease(FsContext);
PDEVICE_OBJECT FsvrtDeviceObject = FsvolDeviceExtension->FsvrtDeviceObject;
if (!FspDeviceRetain(FsvrtDeviceObject))
/* IRP_MJ_CLOSE cannot really fail :-\ */
return STATUS_SUCCESS;
try
{
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(FsvrtDeviceObject);
BOOLEAN FileNameRequired = 0 != FsvrtDeviceExtension->VolumeParams.FileNameRequired;
FSP_FSCTL_TRANSACT_REQ *Request;
/* create the user-mode file system request */
Result = FspIopCreateRequest(0, FileNameRequired ? &FsContext->FileName : 0, 0, &Request);
if (!NT_SUCCESS(Result))
goto leak_exit;
/*
* The new request is associated with our IRP and will be deleted during its completion.
*/
/* populate the Close request */
Request->Kind = FspFsctlTransactCloseKind;
Request->Req.Close.UserContext = UserContext;
Request->Req.Close.UserContext2 = UserContext2;
/* post as a work request; this allows us to complete our own IRP and return immediately! */
if (!FspIopPostWorkRequest(DeviceObject, Request))
/* no need to delete the request here as FspIopPostWorkRequest() will do so in all cases */
goto leak_exit;
Result = STATUS_SUCCESS;
goto exit;
leak_exit:;
#if DBG
DEBUGLOG("FileObject=%p[%p:\"%wZ\"], UserContext=%llx, UserContext2=%llx: "
"error: the user-mode file system handle will be leaked!",
IrpSp->FileObject, IrpSp->FileObject->RelatedFileObject, IrpSp->FileObject->FileName,
UserContext, UserContext2);
#endif
/* IRP_MJ_CLOSE cannot really fail :-\ */
Result = STATUS_SUCCESS;
exit:;
}
finally
{
FspDeviceRelease(FsvrtDeviceObject);
}
return Result;
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolCloseComplete(
@@ -130,8 +62,6 @@ NTSTATUS FspClose(
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_CLOSE == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:

664
src/sys/create.c
View File

@@ -14,9 +14,7 @@ static NTSTATUS FspFsvolCreate(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOPREP_DISPATCH FspFsvolCreatePrepare;
FSP_IOCMPL_DISPATCH FspFsvolCreateComplete;
static VOID FspFsvolCreateCleanupClose(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response);
FSP_IOP_REQUEST_FINI FspFsvolCreateRequestFini;
static FSP_IOP_REQUEST_FINI FspFsvolCreateRequestFini;
FSP_DRIVER_DISPATCH FspCreate;
#ifdef ALLOC_PRAGMA
@@ -25,25 +23,17 @@ FSP_DRIVER_DISPATCH FspCreate;
#pragma alloc_text(PAGE, FspFsvolCreate)
#pragma alloc_text(PAGE, FspFsvolCreatePrepare)
#pragma alloc_text(PAGE, FspFsvolCreateComplete)
#pragma alloc_text(PAGE, FspFsvolCreateCleanupClose)
#pragma alloc_text(PAGE, FspFsvolCreateRequestFini)
#pragma alloc_text(PAGE, FspCreate)
#endif
enum
{
RequestFsContext = 0,
RequestAccessToken,
};
static NTSTATUS FspFsctlCreate(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
PAGED_CODE();
NTSTATUS Result = STATUS_SUCCESS;
Irp->IoStatus.Information = FILE_OPENED;
return Result;
return STATUS_SUCCESS;
}
static NTSTATUS FspFsvrtCreate(
@@ -51,9 +41,8 @@ static NTSTATUS FspFsvrtCreate(
{
PAGED_CODE();
NTSTATUS Result = STATUS_SUCCESS;
Irp->IoStatus.Information = FILE_OPENED;
return Result;
return STATUS_SUCCESS;
}
static NTSTATUS FspFsvolCreate(
@@ -61,280 +50,7 @@ static NTSTATUS FspFsvolCreate(
{
PAGED_CODE();
/* open the volume object? */
if (0 == IrpSp->FileObject->FileName.Length &&
(0 == IrpSp->FileObject->RelatedFileObject ||
0 == IrpSp->FileObject->RelatedFileObject->FsContext))
{
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
PDEVICE_OBJECT FsvrtDeviceObject = FsvolDeviceExtension->FsvrtDeviceObject;
IrpSp->FileObject->Vpb = FsvrtDeviceObject->Vpb;
Irp->IoStatus.Information = FILE_OPENED;
return STATUS_SUCCESS;
}
NTSTATUS Result;
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
PDEVICE_OBJECT FsvrtDeviceObject = FsvolDeviceExtension->FsvrtDeviceObject;
if (!FspDeviceRetain(FsvrtDeviceObject))
return STATUS_CANCELLED;
try
{
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(FsvrtDeviceObject);
PFILE_OBJECT FileObject = IrpSp->FileObject;
PFILE_OBJECT RelatedFileObject = FileObject->RelatedFileObject;
UNICODE_STRING FileName = FileObject->FileName;
PACCESS_STATE AccessState = IrpSp->Parameters.Create.SecurityContext->AccessState;
ULONG CreateOptions = IrpSp->Parameters.Create.Options;
USHORT FileAttributes = IrpSp->Parameters.Create.FileAttributes;
PSECURITY_DESCRIPTOR SecurityDescriptor = AccessState->SecurityDescriptor;
ULONG SecurityDescriptorSize = 0;
LARGE_INTEGER AllocationSize = Irp->Overlay.AllocationSize;
ACCESS_MASK DesiredAccess = IrpSp->Parameters.Create.SecurityContext->DesiredAccess;
USHORT ShareAccess = IrpSp->Parameters.Create.ShareAccess;
PFILE_FULL_EA_INFORMATION EaBuffer = Irp->AssociatedIrp.SystemBuffer;
//ULONG EaLength = IrpSp->Parameters.Create.EaLength;
ULONG Flags = IrpSp->Flags;
KPROCESSOR_MODE RequestorMode =
FlagOn(Flags, SL_FORCE_ACCESS_CHECK) ? UserMode : Irp->RequestorMode;
BOOLEAN HasTraversePrivilege =
BooleanFlagOn(AccessState->Flags, TOKEN_HAS_TRAVERSE_PRIVILEGE);
BOOLEAN IsAbsoluteSecurityDescriptor = FALSE;
BOOLEAN IsSelfRelativeSecurityDescriptor = FALSE;
BOOLEAN HasTrailingBackslash = FALSE;
FSP_FILE_CONTEXT *FsContext = 0;
FSP_FSCTL_TRANSACT_REQ *Request;
/* cannot open a paging file */
if (FlagOn(Flags, SL_OPEN_PAGING_FILE))
{
Result = STATUS_ACCESS_DENIED;
goto exit;
}
/* cannot open files by fileid */
if (FlagOn(CreateOptions, FILE_OPEN_BY_FILE_ID))
{
Result = STATUS_NOT_IMPLEMENTED;
goto exit;
}
/* do we support EA? */
if (0 != EaBuffer && !FsvrtDeviceExtension->VolumeParams.EaSupported)
{
Result = STATUS_EAS_NOT_SUPPORTED;
goto exit;
}
/* check create options */
if (FlagOn(CreateOptions, FILE_NON_DIRECTORY_FILE) &&
FlagOn(CreateOptions, FILE_DIRECTORY_FILE))
{
Result = STATUS_INVALID_PARAMETER;
goto exit;
}
/* check security descriptor validity */
if (0 != SecurityDescriptor)
{
IsAbsoluteSecurityDescriptor = RtlValidSecurityDescriptor(SecurityDescriptor);
if (IsAbsoluteSecurityDescriptor)
{
Result = RtlAbsoluteToSelfRelativeSD(SecurityDescriptor, 0, &SecurityDescriptorSize);
if (STATUS_BUFFER_TOO_SMALL != Result)
{
Result = STATUS_INVALID_PARAMETER;
goto exit;
}
}
else
{
SecurityDescriptorSize = RtlLengthSecurityDescriptor(SecurityDescriptor);
IsSelfRelativeSecurityDescriptor = RtlValidRelativeSecurityDescriptor(
SecurityDescriptor, SecurityDescriptorSize, 0);
if (!IsSelfRelativeSecurityDescriptor)
{
Result = STATUS_INVALID_PARAMETER;
goto exit;
}
}
}
/* according to fastfat, filenames that begin with two backslashes are ok */
if (sizeof(WCHAR) * 2 <= FileName.Length &&
L'\\' == FileName.Buffer[1] && L'\\' == FileName.Buffer[0])
{
FileName.Length -= sizeof(WCHAR);
FileName.MaximumLength -= sizeof(WCHAR);
FileName.Buffer++;
if (sizeof(WCHAR) * 2 <= FileName.Length &&
L'\\' == FileName.Buffer[1] && L'\\' == FileName.Buffer[0])
{
Result = STATUS_OBJECT_NAME_INVALID;
goto exit;
}
}
/* check for trailing backslash */
if (sizeof(WCHAR) * 2/* not empty or root */ <= FileName.Length &&
L'\\' == FileName.Buffer[FileName.Length / 2 - 1])
{
FileName.Length -= sizeof(WCHAR);
HasTrailingBackslash = TRUE;
if (sizeof(WCHAR) * 2 <= FileName.Length && L'\\' == FileName.Buffer[FileName.Length / 2 - 1])
{
Result = STATUS_OBJECT_NAME_INVALID;
goto exit;
}
}
if (HasTrailingBackslash && !FlagOn(CreateOptions, FILE_DIRECTORY_FILE))
{
Result = STATUS_OBJECT_NAME_INVALID;
goto exit;
}
/* is this a relative or absolute open? */
if (0 != RelatedFileObject)
{
FSP_FILE_CONTEXT *RelatedFsContext = RelatedFileObject->FsContext;
/* is this a valid RelatedFileObject? */
if (!FspFileContextIsValid(RelatedFsContext))
{
Result = STATUS_OBJECT_PATH_NOT_FOUND;
goto exit;
}
/* must be a relative path */
if (sizeof(WCHAR) <= FileName.Length && L'\\' == FileName.Buffer[0])
{
Result = STATUS_OBJECT_NAME_INVALID;
goto exit;
}
/* cannot FILE_DELETE_ON_CLOSE on the root directory */
if (sizeof(WCHAR) == RelatedFsContext->FileName.Length &&
0 == FileName.Length &&
FlagOn(CreateOptions, FILE_DELETE_ON_CLOSE))
{
Result = STATUS_CANNOT_DELETE;
goto exit;
}
/*
* There is no need to lock our accesses of RelatedFileObject->FsContext->FileName,
* because RelatedFileObject->FsContext->Filename is read-only (after creation) and
* because RelatedFileObject->FsContext is guaranteed to exist while RelatedFileObject
* exists.
*/
BOOLEAN AppendBackslash =
sizeof(WCHAR) * 2/* not empty or root */ <= RelatedFsContext->FileName.Length &&
sizeof(WCHAR) <= FileName.Length && L':' != FileName.Buffer[0];
Result = FspFileContextCreate(DeviceObject,
RelatedFsContext->FileName.Length + AppendBackslash * sizeof(WCHAR) + FileName.Length,
&FsContext);
if (!NT_SUCCESS(Result))
goto exit;
Result = RtlAppendUnicodeStringToString(&FsContext->FileName, &RelatedFsContext->FileName);
ASSERT(NT_SUCCESS(Result));
if (AppendBackslash)
{
Result = RtlAppendUnicodeToString(&FsContext->FileName, L"\\");
ASSERT(NT_SUCCESS(Result));
}
}
else
{
/* must be an absolute path */
if (sizeof(WCHAR) <= FileName.Length && L'\\' != FileName.Buffer[0])
{
Result = STATUS_OBJECT_NAME_INVALID;
goto exit;
}
/* cannot FILE_DELETE_ON_CLOSE on the root directory */
if (sizeof(WCHAR) == FileName.Length &&
FlagOn(CreateOptions, FILE_DELETE_ON_CLOSE))
{
Result = STATUS_CANNOT_DELETE;
goto exit;
}
Result = FspFileContextCreate(DeviceObject,
FileName.Length,
&FsContext);
if (!NT_SUCCESS(Result))
goto exit;
}
Result = RtlAppendUnicodeStringToString(&FsContext->FileName, &FileName);
ASSERT(NT_SUCCESS(Result));
/* create the user-mode file system request */
Result = FspIopCreateRequestEx(Irp, &FsContext->FileName, SecurityDescriptorSize,
FspFsvolCreateRequestFini, &Request);
if (!NT_SUCCESS(Result))
{
FspFileContextRelease(FsContext);
goto exit;
}
/*
* The new request is associated with our IRP and will be deleted during its completion.
* Go ahead and associate our FsContext with the Request as well.
*/
FspIopRequestContext(Request, RequestFsContext) = FsContext;
/* populate the Create request */
Request->Kind = FspFsctlTransactCreateKind;
Request->Req.Create.CreateOptions = CreateOptions;
Request->Req.Create.FileAttributes = FileAttributes;
Request->Req.Create.SecurityDescriptor.Offset = 0 == SecurityDescriptorSize ? 0 :
FSP_FSCTL_DEFAULT_ALIGN_UP(Request->FileName.Size);
Request->Req.Create.SecurityDescriptor.Size = (UINT16)SecurityDescriptorSize;
Request->Req.Create.AllocationSize = AllocationSize.QuadPart;
Request->Req.Create.AccessToken = 0;
Request->Req.Create.DesiredAccess = DesiredAccess;
Request->Req.Create.ShareAccess = ShareAccess;
Request->Req.Create.Ea.Offset = 0;
Request->Req.Create.Ea.Size = 0;
Request->Req.Create.UserMode = UserMode == RequestorMode;
Request->Req.Create.HasTraversePrivilege = HasTraversePrivilege;
Request->Req.Create.OpenTargetDirectory = BooleanFlagOn(Flags, SL_OPEN_TARGET_DIRECTORY);
Request->Req.Create.CaseSensitive = BooleanFlagOn(Flags, SL_CASE_SENSITIVE);
/* copy the security descriptor into the request */
if (IsAbsoluteSecurityDescriptor)
{
Result = RtlAbsoluteToSelfRelativeSD(SecurityDescriptor,
Request->Buffer + Request->Req.Create.SecurityDescriptor.Offset, &SecurityDescriptorSize);
if (!NT_SUCCESS(Result))
{
if (STATUS_BAD_DESCRIPTOR_FORMAT == Result || STATUS_BUFFER_TOO_SMALL == Result)
Result = STATUS_INVALID_PARAMETER; /* should not happen */
goto exit;
}
}
else if (IsSelfRelativeSecurityDescriptor)
RtlCopyMemory(Request->Buffer + Request->Req.Create.SecurityDescriptor.Offset,
SecurityDescriptor, SecurityDescriptorSize);
Result = STATUS_PENDING;
exit:;
}
finally
{
FspDeviceRelease(FsvrtDeviceObject);
}
return Result;
return STATUS_INVALID_DEVICE_REQUEST;
}
NTSTATUS FspFsvolCreatePrepare(
@@ -342,30 +58,6 @@ NTSTATUS FspFsvolCreatePrepare(
{
FSP_ENTER_IOP(PAGED_CODE());
PDEVICE_OBJECT DeviceObject = IrpSp->DeviceObject;
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension =
FspFsvrtDeviceExtension(FsvolDeviceExtension->FsvrtDeviceObject);
/* is the user-mode file system doing access checks? */
if (!FsvrtDeviceExtension->VolumeParams.NoSystemAccessCheck)
{
ASSERT(0 == Request->Req.Create.AccessToken);
FSP_RETURN(Result = STATUS_SUCCESS);
}
/* get a user-mode handle to the access token */
PACCESS_STATE AccessState = IrpSp->Parameters.Create.SecurityContext->AccessState;
HANDLE UserModeAccessToken;
Result = ObOpenObjectByPointer(SeQuerySubjectContextToken(&AccessState->SubjectSecurityContext),
0, 0, TOKEN_QUERY, *SeTokenObjectType, UserMode, &UserModeAccessToken);
if (!NT_SUCCESS(Result))
FSP_RETURN();
/* send the user-mode handle to the user-mode file system */
FspIopRequestContext(Request, RequestAccessToken) = UserModeAccessToken;
Request->Req.Create.AccessToken = (UINT_PTR)UserModeAccessToken;
FSP_LEAVE_IOP();
}
@@ -374,358 +66,14 @@ VOID FspFsvolCreateComplete(
{
FSP_ENTER_IOC(PAGED_CODE());
/*
* NOTE:
* In the following we may have to close the just opened file object. But we must
* never close a file we just created, because this will leave an orphan file on
* the disk.
*
* Files may have to be closed if a security access or share access check fails. In
* both those cases we were opening an existing file and so it is safe to close it.
*
* Because of how IRP_MJ_CREATE works in Windows, it is difficult to improve on this
* scheme without introducing a 2-phase Create protocol, which is undesirable as it
* means two trips into user-mode for a single Create request.
*/
PDEVICE_OBJECT DeviceObject = IrpSp->DeviceObject;
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
PDEVICE_OBJECT FsvrtDeviceObject = FsvolDeviceExtension->FsvrtDeviceObject;
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(FsvrtDeviceObject);
FSP_FSCTL_TRANSACT_REQ *Request = FspIrpRequest(Irp);
PFILE_OBJECT FileObject = IrpSp->FileObject;
PACCESS_STATE AccessState = IrpSp->Parameters.Create.SecurityContext->AccessState;
ULONG CreateOptions = IrpSp->Parameters.Create.Options;
BOOLEAN FileCreated = FILE_CREATED == Response->IoStatus.Information;
UINT32 ResponseFileAttributes = Response->Rsp.Create.Opened.FileAttributes;
PSECURITY_DESCRIPTOR SecurityDescriptor;
ULONG SecurityDescriptorSize;
UNICODE_STRING ReparseFileName;
ACCESS_MASK DesiredAccess = IrpSp->Parameters.Create.SecurityContext->DesiredAccess;
PPRIVILEGE_SET Privileges = 0;
USHORT ShareAccess = IrpSp->Parameters.Create.ShareAccess;
ULONG Flags = IrpSp->Flags;
KPROCESSOR_MODE RequestorMode =
FlagOn(Flags, SL_FORCE_ACCESS_CHECK) ? UserMode : Irp->RequestorMode;
FSP_FILE_CONTEXT *FsContext = FspIopRequestContext(Request, RequestFsContext);
ACCESS_MASK GrantedAccess;
BOOLEAN Inserted = FALSE;
/* did the user-mode file system sent us a failure code? */
if (!NT_SUCCESS(Response->IoStatus.Status))
{
Irp->IoStatus.Information = Response->IoStatus.Information;
Result = Response->IoStatus.Status;
FSP_RETURN();
}
/* special case STATUS_REPARSE */
if (STATUS_REPARSE == Result)
{
ReparseFileName.Buffer =
(PVOID)(Response->Buffer + Response->Rsp.Create.Reparse.FileName.Offset);
ReparseFileName.Length = ReparseFileName.MaximumLength =
Response->Rsp.Create.Reparse.FileName.Size;
Result = STATUS_ACCESS_DENIED;
if (IO_REPARSE == Response->IoStatus.Information)
{
if (0 == ReparseFileName.Length ||
(PUINT8)ReparseFileName.Buffer + ReparseFileName.Length >
(PUINT8)Response + Response->Size)
FSP_RETURN();
if (ReparseFileName.Length > FileObject->FileName.MaximumLength)
{
PVOID Buffer = FspAllocExternal(ReparseFileName.Length);
if (0 == Buffer)
FSP_RETURN(Result = STATUS_INSUFFICIENT_RESOURCES);
FspFreeExternal(FileObject->FileName.Buffer);
FileObject->FileName.MaximumLength = ReparseFileName.Length;
FileObject->FileName.Buffer = Buffer;
}
FileObject->FileName.Length = 0;
RtlCopyUnicodeString(&FileObject->FileName, &ReparseFileName);
}
else
if (IO_REMOUNT == Response->IoStatus.Information)
{
if (0 != ReparseFileName.Length)
FSP_RETURN();
}
else
FSP_RETURN();
Irp->IoStatus.Information = Response->IoStatus.Information;
Result = Response->IoStatus.Status;
FSP_RETURN();
}
/* are we doing access checks? */
if (!FsvrtDeviceExtension->VolumeParams.NoSystemAccessCheck)
{
/* read-only attribute check */
if (!FileCreated && FlagOn(ResponseFileAttributes, FILE_ATTRIBUTE_READONLY))
{
/* from fastfat: allowed accesses when read-only */
ACCESS_MASK Allowed =
DELETE | READ_CONTROL | WRITE_OWNER | WRITE_DAC |
SYNCHRONIZE | ACCESS_SYSTEM_SECURITY |
FILE_READ_DATA | FILE_READ_EA | FILE_WRITE_EA |
FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES |
FILE_EXECUTE | FILE_TRAVERSE | FILE_LIST_DIRECTORY |
FILE_ADD_SUBDIRECTORY | FILE_ADD_FILE | FILE_DELETE_CHILD;
if (FlagOn(DesiredAccess, ~Allowed))
{
FspFsvolCreateCleanupClose(Irp, Response);
FSP_RETURN(Result = STATUS_ACCESS_DENIED);
}
else
if (!FlagOn(ResponseFileAttributes, FILE_ATTRIBUTE_DIRECTORY) &&
FlagOn(CreateOptions, FILE_DELETE_ON_CLOSE))
{
FspFsvolCreateCleanupClose(Irp, Response);
FSP_RETURN(Result = STATUS_CANNOT_DELETE);
}
}
/* security descriptor check */
SecurityDescriptor =
(PVOID)(Response->Buffer + Response->Rsp.Create.Opened.SecurityDescriptor.Offset);
SecurityDescriptorSize = Response->Rsp.Create.Opened.SecurityDescriptor.Size;
if (0 != SecurityDescriptorSize)
{
if ((PUINT8)SecurityDescriptor + SecurityDescriptorSize >
(PUINT8)Response + Response->Size ||
!FspValidRelativeSecurityDescriptor(SecurityDescriptor, SecurityDescriptorSize, 0))
{
FspFsvolCreateCleanupClose(Irp, Response);
FSP_RETURN(Result = STATUS_ACCESS_DENIED);
}
/* access check */
if (!SeAccessCheck(SecurityDescriptor,
&AccessState->SubjectSecurityContext,
FALSE,
DesiredAccess,
AccessState->PreviouslyGrantedAccess,
&Privileges,
IoGetFileObjectGenericMapping(),
RequestorMode,
&GrantedAccess,
&Result))
{
FspFsvolCreateCleanupClose(Irp, Response);
FSP_RETURN();
}
if (0 != Privileges)
{
Result = SeAppendPrivileges(AccessState, Privileges);
SeFreePrivileges(Privileges);
if (!NT_SUCCESS(Result))
{
FspFsvolCreateCleanupClose(Irp, Response);
FSP_RETURN();
}
}
SetFlag(AccessState->PreviouslyGrantedAccess, GrantedAccess);
ClearFlag(AccessState->RemainingDesiredAccess, GrantedAccess);
}
}
/* were we asked to open a directory or non-directory? */
if (FlagOn(CreateOptions, FILE_DIRECTORY_FILE) &&
!FileCreated && !FlagOn(ResponseFileAttributes, FILE_ATTRIBUTE_DIRECTORY))
{
FspFsvolCreateCleanupClose(Irp, Response);
FSP_RETURN(Result = STATUS_NOT_A_DIRECTORY);
}
if (FlagOn(CreateOptions, FILE_NON_DIRECTORY_FILE) &&
!FileCreated && FlagOn(ResponseFileAttributes, FILE_ATTRIBUTE_DIRECTORY))
{
FspFsvolCreateCleanupClose(Irp, Response);
FSP_RETURN(Result = STATUS_FILE_IS_A_DIRECTORY);
}
/*
* The following must be done under the file system volume device Resource,
* because we are manipulating its GenericTable and accessing foreign FsContext's.
*/
ExAcquireResourceExclusiveLite(&FsvolDeviceExtension->Base.Resource, TRUE);
try
{
/* insert the newly created FsContext into our generic table */
FsContext = FspFsvolDeviceInsertContext(DeviceObject,
FsContext->UserContext, FsContext, &FsContext->ElementStorage, &Inserted);
ASSERT(0 != FsContext);
/* share access check */
if (Inserted)
{
/*
* This is a newly created FsContext. Set its share access and
* increment its open count. There is no need to acquire the
* FsContext's Resource (because it is newly created).
*/
IoSetShareAccess(AccessState->PreviouslyGrantedAccess,
ShareAccess, FileObject, &FsContext->ShareAccess);
FspFileContextOpen(FsContext);
if (FlagOn(CreateOptions, FILE_DELETE_ON_CLOSE))
FsContext->DeleteOnClose = TRUE;
Result = STATUS_SUCCESS;
}
else
{
/*
* This is an existing FsContext. We must acquire its Resource and
* check if there is a delete pending and the share access. Only if
* both tests succeed we increment the open count and report success.
*/
ExAcquireResourceExclusiveLite(FsContext->Header.Resource, TRUE);
if (FsContext->DeletePending)
Result = STATUS_DELETE_PENDING;
else
Result = IoCheckShareAccess(AccessState->PreviouslyGrantedAccess,
ShareAccess, FileObject, &FsContext->ShareAccess, TRUE);
if (NT_SUCCESS(Result))
{
FspFileContextRetain(FsContext);
FspFileContextOpen(FsContext);
if (FlagOn(CreateOptions, FILE_DELETE_ON_CLOSE))
FsContext->DeleteOnClose = TRUE;
}
ExReleaseResourceLite(FsContext->Header.Resource);
}
}
finally
{
ExReleaseResourceLite(&FsvolDeviceExtension->Base.Resource);
}
/* did we fail our share access checks? */
if (!NT_SUCCESS(Result))
{
ASSERT(!Inserted);
FspFsvolCreateCleanupClose(Irp, Response);
FSP_RETURN();
}
/*
* Looks like SUCCESS!
*/
/* did an FsContext with the same UserContext already exist? */
if (!Inserted)
/* delete the newly created FsContext as it is not being used */
FspFileContextRelease(FspIopRequestContext(Request, RequestFsContext));
/* disassociate our FsContext from the Request */
FspIopRequestContext(Request, RequestFsContext) = 0;
/* record the user-mode file system contexts */
FsContext->UserContext = Response->Rsp.Create.Opened.UserContext;
FileObject->FsContext = FsContext;
FileObject->FsContext2 = (PVOID)(UINT_PTR)Response->Rsp.Create.Opened.UserContext2;
/* finish seting up the FileObject */
FileObject->Vpb = FsvrtDeviceObject->Vpb;
/* SUCCESS! */
Irp->IoStatus.Information = Response->IoStatus.Information;
Result = Response->IoStatus.Status;
FSP_LEAVE_IOC(
"FileObject=%p[%p:\"%wZ\"]",
IrpSp->FileObject, IrpSp->FileObject->RelatedFileObject, IrpSp->FileObject->FileName);
}
static VOID FspFsvolCreateCleanupClose(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
static VOID FspFsvolCreateRequestFini(PVOID Context[3])
{
PAGED_CODE();
/*
* This routine handles the case where we must close an open file,
* because of a failure during Create completion. We simply create
* a CreateClose request and we post it as a work item.
*
* Ideally there would be no failure modes for this routine. Reality is
* different.
*
* The more serious (but perhaps non-existent in practice) failure is a
* memory allocation failure. In this case we will leak the user-mode
* file system handle!
*
* This routine may also fail if we cannot post a work item, which means that
* the virtual volume device and the file system volume device are being
* deleted. Because it is assumed that only the user-mode file system would
* initiate a device deletion, this case is more benign (presumably the file
* system knows to close off all its handles when tearing down its devices).
*/
NTSTATUS Result;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
PDEVICE_OBJECT DeviceObject = IrpSp->DeviceObject;
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension =
FspFsvrtDeviceExtension(FsvolDeviceExtension->FsvrtDeviceObject);
FSP_FSCTL_TRANSACT_REQ *OriginalRequest = FspIrpRequest(Irp);
FSP_FILE_CONTEXT *FsContext = FspIopRequestContext(OriginalRequest, RequestFsContext);
UINT64 UserContext = Response->Rsp.Create.Opened.UserContext;
UINT64 UserContext2 = Response->Rsp.Create.Opened.UserContext2;
BOOLEAN FileNameRequired = 0 != FsvrtDeviceExtension->VolumeParams.FileNameRequired;
FSP_FSCTL_TRANSACT_REQ *Request;
/* create the user-mode file system request */
Result = FspIopCreateRequest(0, FileNameRequired ? &FsContext->FileName : 0, 0, &Request);
if (!NT_SUCCESS(Result))
goto leak_exit;
/* populate the CreateCleanupClose request */
Request->Kind = FspFsctlTransactCreateCleanupCloseKind;
Request->Req.Cleanup.UserContext = UserContext;
Request->Req.Cleanup.UserContext2 = UserContext2;
Request->Req.Cleanup.Delete = FILE_CREATED == Response->IoStatus.Information;
/* post as a work request */
if (!FspIopPostWorkRequest(DeviceObject, Request))
/* no need to delete the request here as FspIopPostWorkRequest() will do so in all cases */
goto leak_exit;
goto exit;
leak_exit:;
#if DBG
DEBUGLOG("FileObject=%p[%p:\"%wZ\"], UserContext=%llx, UserContext2=%llx: "
"error: the user-mode file system handle will be leaked!",
IrpSp->FileObject, IrpSp->FileObject->RelatedFileObject, IrpSp->FileObject->FileName,
UserContext, UserContext2);
#endif
exit:;
}
VOID FspFsvolCreateRequestFini(PVOID Context[3])
{
PAGED_CODE();
if (0 != Context[RequestFsContext])
FspFileContextRelease(Context[RequestFsContext]);
if (0 != Context[RequestAccessToken])
{
#if DBG
NTSTATUS Result0;
Result0 = ObCloseHandle(Context[RequestAccessToken], KernelMode);
if (!NT_SUCCESS(Result0))
DEBUGLOG("ObCloseHandle() = %s", NtStatusSym(Result0));
#else
ObCloseHandle(Context[RequestAccessToken], KernelMode);
#endif
}
}
NTSTATUS FspCreate(
@@ -733,8 +81,6 @@ NTSTATUS FspCreate(
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_CREATE == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:

1
src/sys/debug.c
View File

@@ -166,7 +166,6 @@ const char *IoctlCodeSym(ULONG ControlCode)
switch (ControlCode)
{
SYM(FSP_FSCTL_CREATE)
SYM(FSP_FSCTL_DELETE)
SYM(FSP_FSCTL_TRANSACT)
SYM(FSP_FSCTL_WORK)
default:

22
src/sys/devctl.c
View File

@@ -8,13 +8,13 @@
static NTSTATUS FspFsvolDeviceControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolDeviceControlComplete;
FSP_DRIVER_DISPATCH FspDeviceControl;
FSP_IOCMPL_DISPATCH FspDeviceControlComplete;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFsvolDeviceControl)
#pragma alloc_text(PAGE, FspFsvolDeviceControlComplete)
#pragma alloc_text(PAGE, FspDeviceControl)
#pragma alloc_text(PAGE, FspDeviceControlComplete)
#endif
static NTSTATUS FspFsvolDeviceControl(
@@ -25,13 +25,19 @@ static NTSTATUS FspFsvolDeviceControl(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolDeviceControlComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
NTSTATUS FspDeviceControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_DEVICE_CONTROL == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -42,11 +48,3 @@ NTSTATUS FspDeviceControl(
FSP_LEAVE_MJ("%s", "");
}
VOID FspDeviceControlComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}

440
src/sys/device.c
View File

@@ -15,29 +15,21 @@ NTSTATUS FspDeviceCreate(UINT32 Kind, ULONG ExtraSize,
PDEVICE_OBJECT *PDeviceObject);
VOID FspDeviceInitComplete(PDEVICE_OBJECT DeviceObject);
VOID FspDeviceDelete(PDEVICE_OBJECT DeviceObject);
static NTSTATUS FspFsctlDeviceInit(PDEVICE_OBJECT DeviceObject);
static VOID FspFsctlDeviceInitComplete(PDEVICE_OBJECT DeviceObject);
static VOID FspFsctlDeviceFini(PDEVICE_OBJECT DeviceObject);
static NTSTATUS FspFsvrtDeviceInit(PDEVICE_OBJECT DeviceObject);
static VOID FspFsvrtDeviceInitComplete(PDEVICE_OBJECT DeviceObject);
static VOID FspFsvrtDeviceFini(PDEVICE_OBJECT DeviceObject);
BOOLEAN FspDeviceRetain(PDEVICE_OBJECT DeviceObject);
VOID FspDeviceRelease(PDEVICE_OBJECT DeviceObject);
PVOID FspDeviceLookupContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier);
PVOID FspDeviceInsertContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier, PVOID Context,
FSP_DEVICE_GENERIC_TABLE_ELEMENT *ElementStorage, PBOOLEAN PInserted);
VOID FspDeviceDeleteContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier,
PBOOLEAN PDeleted);
static RTL_AVL_COMPARE_ROUTINE FspDeviceCompareElement;
static RTL_AVL_ALLOCATE_ROUTINE FspDeviceAllocateElement;
static RTL_AVL_FREE_ROUTINE FspDeviceFreeElement;
static NTSTATUS FspFsvolDeviceInit(PDEVICE_OBJECT DeviceObject);
static VOID FspFsvolDeviceInitComplete(PDEVICE_OBJECT DeviceObject);
static VOID FspFsvolDeviceFini(PDEVICE_OBJECT DeviceObject);
BOOLEAN FspDeviceRetain(PDEVICE_OBJECT DeviceObject);
VOID FspDeviceRelease(PDEVICE_OBJECT DeviceObject);
VOID FspFsctlDeviceVolumeCreated(PDEVICE_OBJECT DeviceObject);
VOID FspFsctlDeviceVolumeDeleted(PDEVICE_OBJECT DeviceObject);
static IO_TIMER_ROUTINE FspFsvrtDeviceTimerRoutine;
static WORKER_THREAD_ROUTINE FspFsvrtDeviceExpirationRoutine;
PVOID FspFsvolDeviceLookupContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier);
PVOID FspFsvolDeviceInsertContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier, PVOID Context,
FSP_DEVICE_GENERIC_TABLE_ELEMENT *ElementStorage, PBOOLEAN PInserted);
VOID FspFsvolDeviceDeleteContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier,
PBOOLEAN PDeleted);
static RTL_AVL_COMPARE_ROUTINE FspFsvolDeviceCompareElement;
static RTL_AVL_ALLOCATE_ROUTINE FspFsvolDeviceAllocateElement;
static RTL_AVL_FREE_ROUTINE FspFsvolDeviceFreeElement;
static IO_TIMER_ROUTINE FspFsvolDeviceTimerRoutine;
static WORKER_THREAD_ROUTINE FspFsvolDeviceExpirationRoutine;
NTSTATUS FspDeviceCopyList(
PDEVICE_OBJECT **PDeviceObjects, PULONG PDeviceObjectCount);
VOID FspDeviceDeleteList(
@@ -49,23 +41,15 @@ VOID FspDeviceDeleteAll(VOID);
#pragma alloc_text(PAGE, FspDeviceCreate)
#pragma alloc_text(PAGE, FspDeviceInitComplete)
#pragma alloc_text(PAGE, FspDeviceDelete)
#pragma alloc_text(PAGE, FspFsctlDeviceInit)
#pragma alloc_text(PAGE, FspFsctlDeviceInitComplete)
#pragma alloc_text(PAGE, FspFsctlDeviceFini)
#pragma alloc_text(PAGE, FspFsvrtDeviceInit)
#pragma alloc_text(PAGE, FspFsvrtDeviceInitComplete)
#pragma alloc_text(PAGE, FspFsvrtDeviceFini)
#pragma alloc_text(PAGE, FspDeviceLookupContext)
#pragma alloc_text(PAGE, FspDeviceInsertContext)
#pragma alloc_text(PAGE, FspDeviceDeleteContext)
#pragma alloc_text(PAGE, FspDeviceCompareElement)
#pragma alloc_text(PAGE, FspDeviceAllocateElement)
#pragma alloc_text(PAGE, FspDeviceFreeElement)
#pragma alloc_text(PAGE, FspFsvolDeviceInit)
#pragma alloc_text(PAGE, FspFsvolDeviceInitComplete)
#pragma alloc_text(PAGE, FspFsvolDeviceFini)
#pragma alloc_text(PAGE, FspFsctlDeviceVolumeCreated)
#pragma alloc_text(PAGE, FspFsctlDeviceVolumeDeleted)
#pragma alloc_text(PAGE, FspFsvolDeviceLookupContext)
#pragma alloc_text(PAGE, FspFsvolDeviceInsertContext)
#pragma alloc_text(PAGE, FspFsvolDeviceDeleteContext)
#pragma alloc_text(PAGE, FspFsvolDeviceCompareElement)
#pragma alloc_text(PAGE, FspFsvolDeviceAllocateElement)
#pragma alloc_text(PAGE, FspFsvolDeviceFreeElement)
#pragma alloc_text(PAGE, FspDeviceCopyList)
#pragma alloc_text(PAGE, FspDeviceDeleteList)
#pragma alloc_text(PAGE, FspDeviceDeleteAll)
@@ -89,10 +73,10 @@ NTSTATUS FspDeviceCreateSecure(UINT32 Kind, ULONG ExtraSize,
DeviceExtensionSize = sizeof(FSP_FSVOL_DEVICE_EXTENSION);
break;
case FspFsvrtDeviceExtensionKind:
DeviceExtensionSize = sizeof(FSP_FSVRT_DEVICE_EXTENSION);
DeviceExtensionSize = 0;
break;
case FspFsctlDeviceExtensionKind:
DeviceExtensionSize = sizeof(FSP_FSCTL_DEVICE_EXTENSION);
DeviceExtensionSize = 0;
break;
default:
ASSERT(0);
@@ -117,6 +101,8 @@ NTSTATUS FspDeviceCreateSecure(UINT32 Kind, ULONG ExtraSize,
KeInitializeSpinLock(&DeviceExtension->SpinLock);
DeviceExtension->RefCount = 1;
ExInitializeResourceLite(&DeviceExtension->Resource);
RtlInitializeGenericTableAvl(&DeviceExtension->GenericTable,
FspDeviceCompareElement, FspDeviceAllocateElement, FspDeviceFreeElement, 0);
DeviceExtension->Kind = Kind;
switch (Kind)
@@ -125,15 +111,24 @@ NTSTATUS FspDeviceCreateSecure(UINT32 Kind, ULONG ExtraSize,
Result = FspFsvolDeviceInit(DeviceObject);
break;
case FspFsvrtDeviceExtensionKind:
Result = FspFsvrtDeviceInit(DeviceObject);
break;
case FspFsctlDeviceExtensionKind:
Result = FspFsctlDeviceInit(DeviceObject);
break;
}
if (!NT_SUCCESS(Result))
{
#if 0
/* FspDeviceFreeElement is now a no-op, so this is no longer necessary */
/*
* Enumerate and delete all entries in the GenericTable.
* There is no need to protect accesses to the table as we are in the device destructor.
*/
FSP_DEVICE_GENERIC_TABLE_ELEMENT_DATA *Element;
while (0 != (Element = RtlGetElementGenericTableAvl(&DeviceExtension->GenericTable, 0)))
RtlDeleteElementGenericTableAvl(&DeviceExtension->GenericTable, &Element->Identifier);
#endif
ExDeleteResourceLite(&DeviceExtension->Resource);
IoDeleteDevice(DeviceObject);
}
@@ -164,10 +159,8 @@ VOID FspDeviceInitComplete(PDEVICE_OBJECT DeviceObject)
FspFsvolDeviceInitComplete(DeviceObject);
break;
case FspFsvrtDeviceExtensionKind:
FspFsvrtDeviceInitComplete(DeviceObject);
break;
case FspFsctlDeviceExtensionKind:
FspFsctlDeviceInitComplete(DeviceObject);
break;
default:
ASSERT(0);
@@ -189,128 +182,27 @@ VOID FspDeviceDelete(PDEVICE_OBJECT DeviceObject)
FspFsvolDeviceFini(DeviceObject);
break;
case FspFsvrtDeviceExtensionKind:
FspFsvrtDeviceFini(DeviceObject);
break;
case FspFsctlDeviceExtensionKind:
FspFsctlDeviceFini(DeviceObject);
break;
default:
ASSERT(0);
return;
}
ExDeleteResourceLite(&DeviceExtension->Resource);
IoDeleteDevice(DeviceObject);
}
static NTSTATUS FspFsctlDeviceInit(PDEVICE_OBJECT DeviceObject)
{
PAGED_CODE();
return STATUS_SUCCESS;
}
static VOID FspFsctlDeviceInitComplete(PDEVICE_OBJECT DeviceObject)
{
PAGED_CODE();
}
static VOID FspFsctlDeviceFini(PDEVICE_OBJECT DeviceObject)
{
PAGED_CODE();
}
static NTSTATUS FspFsvrtDeviceInit(PDEVICE_OBJECT DeviceObject)
{
PAGED_CODE();
NTSTATUS Result;
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(DeviceObject);
/* initialize our timer routine */
Result = IoInitializeTimer(DeviceObject, FspFsvrtDeviceTimerRoutine, 0);
if (!NT_SUCCESS(Result))
return Result;
FspIoqInitialize(&FsvrtDeviceExtension->Ioq);
KeInitializeSpinLock(&FsvrtDeviceExtension->ExpirationLock);
ExInitializeWorkItem(&FsvrtDeviceExtension->ExpirationWorkItem,
FspFsvrtDeviceExpirationRoutine, DeviceObject);
FsvrtDeviceExtension->SwapVpb = FspAllocNonPagedExternal(sizeof *FsvrtDeviceExtension->SwapVpb);
if (0 == FsvrtDeviceExtension->SwapVpb)
return STATUS_INSUFFICIENT_RESOURCES;
RtlZeroMemory(FsvrtDeviceExtension->SwapVpb, sizeof *FsvrtDeviceExtension->SwapVpb);
return STATUS_SUCCESS;
}
static VOID FspFsvrtDeviceInitComplete(PDEVICE_OBJECT DeviceObject)
{
PAGED_CODE();
IoStartTimer(DeviceObject);
}
static VOID FspFsvrtDeviceFini(PDEVICE_OBJECT DeviceObject)
{
PAGED_CODE();
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(DeviceObject);
/*
* First things first: stop our timer.
*
* Our IoTimer routine will NOT be called again after IoStopTimer() returns.
* However a work item may be in flight. For this reason our IoTimer routine
* does an ObReferenceObject() on our DeviceObject before queueing work items.
*/
IoStopTimer(DeviceObject);
if (0 != FsvrtDeviceExtension->SwapVpb)
FspFreeExternal(FsvrtDeviceExtension->SwapVpb);
}
static NTSTATUS FspFsvolDeviceInit(PDEVICE_OBJECT DeviceObject)
{
PAGED_CODE();
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
RtlInitializeGenericTableAvl(&FsvolDeviceExtension->GenericTable,
FspFsvolDeviceCompareElement, FspFsvolDeviceAllocateElement, FspFsvolDeviceFreeElement, 0);
return STATUS_SUCCESS;
}
static VOID FspFsvolDeviceInitComplete(PDEVICE_OBJECT DeviceObject)
{
PAGED_CODE();
}
static VOID FspFsvolDeviceFini(PDEVICE_OBJECT DeviceObject)
{
PAGED_CODE();
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
#if 0
/* FspFsvolDeviceFreeElement is now a no-op, so this is no longer necessary */
/* FspDeviceFreeElement is now a no-op, so this is no longer necessary */
/*
* Enumerate and delete all entries in the GenericTable.
* There is no need to protect accesses to the table as we are in the device destructor.
*/
FSP_DEVICE_GENERIC_TABLE_ELEMENT_DATA *Element;
while (0 != (Element = RtlGetElementGenericTableAvl(&FsvolDeviceExtension->GenericTable, 0)))
RtlDeleteElementGenericTableAvl(&FsvolDeviceExtension->GenericTable, &Element->Identifier);
while (0 != (Element = RtlGetElementGenericTableAvl(&DeviceExtension->GenericTable, 0)))
RtlDeleteElementGenericTableAvl(&DeviceExtension->GenericTable, &Element->Identifier);
#endif
/*
* Dereference the virtual volume device so that it can now go away.
*/
if (0 != FsvolDeviceExtension->FsvrtDeviceObject)
ObDereferenceObject(FsvolDeviceExtension->FsvrtDeviceObject);
ExDeleteResourceLite(&DeviceExtension->Resource);
IoDeleteDevice(DeviceObject);
}
BOOLEAN FspDeviceRetain(PDEVICE_OBJECT DeviceObject)
@@ -352,144 +244,60 @@ VOID FspDeviceRelease(PDEVICE_OBJECT DeviceObject)
FspDeviceDelete(DeviceObject);
}
VOID FspFsctlDeviceVolumeCreated(PDEVICE_OBJECT DeviceObject)
PVOID FspDeviceLookupContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier)
{
PAGED_CODE();
ASSERT(FspFsctlDeviceExtensionKind == FspDeviceExtension(DeviceObject)->Kind);
ASSERT(ExIsResourceAcquiredExclusiveLite(&FspDeviceExtension(DeviceObject)->Resource));
#if 1
FspFsctlDeviceExtension(DeviceObject)->FsvrtDeviceObjectCount++;
#else
ULONG FsvrtDeviceObjectCount = FspFsctlDeviceExtension(DeviceObject)->FsvrtDeviceObjectCount++;
if (0 == FsvrtDeviceObjectCount)
IoRegisterFileSystem(DeviceObject);
#endif
}
VOID FspFsctlDeviceVolumeDeleted(PDEVICE_OBJECT DeviceObject)
{
PAGED_CODE();
ASSERT(FspFsctlDeviceExtensionKind == FspDeviceExtension(DeviceObject)->Kind);
ASSERT(ExIsResourceAcquiredExclusiveLite(&FspDeviceExtension(DeviceObject)->Resource));
#if 1
--FspFsctlDeviceExtension(DeviceObject)->FsvrtDeviceObjectCount;
#else
ULONG FsvrtDeviceObjectCount = --FspFsctlDeviceExtension(DeviceObject)->FsvrtDeviceObjectCount;
if (0 == FsvrtDeviceObjectCount)
IoUnregisterFileSystem(DeviceObject);
#endif
}
static VOID FspFsvrtDeviceTimerRoutine(PDEVICE_OBJECT DeviceObject, PVOID Context)
{
// !PAGED_CODE();
/*
* This routine runs at DPC level. Reference our DeviceObject and queue a work item
* so that we can do our processing at Passive level. Only do so if the work item
* is not already in flight (otherwise we could requeue the same work item).
*/
ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(DeviceObject);
KeAcquireSpinLockAtDpcLevel(&FsvrtDeviceExtension->ExpirationLock);
if (!FsvrtDeviceExtension->ExpirationInProgress)
{
FsvrtDeviceExtension->ExpirationInProgress = TRUE;
ObReferenceObject(DeviceObject);
ExQueueWorkItem(&FsvrtDeviceExtension->ExpirationWorkItem, DelayedWorkQueue);
}
KeReleaseSpinLockFromDpcLevel(&FsvrtDeviceExtension->ExpirationLock);
}
static VOID FspFsvrtDeviceExpirationRoutine(PVOID Context)
{
// !PAGED_CODE();
PDEVICE_OBJECT DeviceObject = Context;
if (FspDeviceRetain(DeviceObject))
try
{
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(DeviceObject);
LARGE_INTEGER Timeout;
KIRQL Irql;
Timeout.QuadPart = FsvrtDeviceExtension->VolumeParams.IrpTimeout * 10000;
/* convert millis to nanos */
FspIoqRemoveExpired(&FsvrtDeviceExtension->Ioq, &Timeout);
KeAcquireSpinLock(&FsvrtDeviceExtension->ExpirationLock, &Irql);
FsvrtDeviceExtension->ExpirationInProgress = FALSE;
KeReleaseSpinLock(&FsvrtDeviceExtension->ExpirationLock, Irql);
}
finally
{
FspDeviceRelease(DeviceObject);
}
ObDereferenceObject(DeviceObject);
}
PVOID FspFsvolDeviceLookupContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier)
{
PAGED_CODE();
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
ASSERT(FspFsvolDeviceExtensionKind == FsvolDeviceExtension->Base.Kind);
ASSERT(ExIsResourceAcquiredExclusiveLite(&FsvolDeviceExtension->Base.Resource));
FSP_DEVICE_EXTENSION *DeviceExtension = FspDeviceExtension(DeviceObject);
ASSERT(ExIsResourceAcquiredExclusiveLite(&DeviceExtension->Resource));
FSP_DEVICE_GENERIC_TABLE_ELEMENT_DATA *Result;
Result = RtlLookupElementGenericTableAvl(&FsvolDeviceExtension->GenericTable, &Identifier);
Result = RtlLookupElementGenericTableAvl(&DeviceExtension->GenericTable, &Identifier);
return 0 != Result ? Result->Context : 0;
}
PVOID FspFsvolDeviceInsertContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier, PVOID Context,
PVOID FspDeviceInsertContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier, PVOID Context,
FSP_DEVICE_GENERIC_TABLE_ELEMENT *ElementStorage, PBOOLEAN PInserted)
{
PAGED_CODE();
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
ASSERT(FspFsvolDeviceExtensionKind == FsvolDeviceExtension->Base.Kind);
ASSERT(ExIsResourceAcquiredExclusiveLite(&FsvolDeviceExtension->Base.Resource));
FSP_DEVICE_EXTENSION *DeviceExtension = FspDeviceExtension(DeviceObject);
ASSERT(ExIsResourceAcquiredExclusiveLite(&DeviceExtension->Resource));
ASSERT(0 != ElementStorage);
FSP_DEVICE_GENERIC_TABLE_ELEMENT_DATA *Result, Element = { 0 };
Element.Identifier = Identifier;
Element.Context = Context;
FsvolDeviceExtension->GenericTableElementStorage = ElementStorage;
Result = RtlInsertElementGenericTableAvl(&FsvolDeviceExtension->GenericTable,
DeviceExtension->GenericTableElementStorage = ElementStorage;
Result = RtlInsertElementGenericTableAvl(&DeviceExtension->GenericTable,
&Element, sizeof Element, PInserted);
FsvolDeviceExtension->GenericTableElementStorage = 0;
DeviceExtension->GenericTableElementStorage = 0;
return 0 != Result ? Result->Context : 0;
ASSERT(0 != Result);
return Result->Context;
}
VOID FspFsvolDeviceDeleteContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier,
VOID FspDeviceDeleteContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier,
PBOOLEAN PDeleted)
{
PAGED_CODE();
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
ASSERT(FspFsvolDeviceExtensionKind == FsvolDeviceExtension->Base.Kind);
ASSERT(ExIsResourceAcquiredExclusiveLite(&FsvolDeviceExtension->Base.Resource));
FSP_DEVICE_EXTENSION *DeviceExtension = FspDeviceExtension(DeviceObject);
ASSERT(ExIsResourceAcquiredExclusiveLite(&DeviceExtension->Resource));
BOOLEAN Deleted;
Deleted = RtlDeleteElementGenericTableAvl(&FsvolDeviceExtension->GenericTable, &Identifier);
Deleted = RtlDeleteElementGenericTableAvl(&DeviceExtension->GenericTable, &Identifier);
if (0 != PDeleted)
*PDeleted = Deleted;
}
static RTL_GENERIC_COMPARE_RESULTS NTAPI FspFsvolDeviceCompareElement(
static RTL_GENERIC_COMPARE_RESULTS NTAPI FspDeviceCompareElement(
PRTL_AVL_TABLE Table, PVOID FirstElement, PVOID SecondElement)
{
PAGED_CODE();
@@ -503,25 +311,149 @@ static RTL_GENERIC_COMPARE_RESULTS NTAPI FspFsvolDeviceCompareElement(
return GenericEqual;
}
static PVOID NTAPI FspFsvolDeviceAllocateElement(
static PVOID NTAPI FspDeviceAllocateElement(
PRTL_AVL_TABLE Table, CLONG ByteSize)
{
PAGED_CODE();
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension =
CONTAINING_RECORD(Table, FSP_FSVOL_DEVICE_EXTENSION, GenericTable);
FSP_DEVICE_EXTENSION *DeviceExtension =
CONTAINING_RECORD(Table, FSP_DEVICE_EXTENSION, GenericTable);
ASSERT(sizeof(FSP_DEVICE_GENERIC_TABLE_ELEMENT) == ByteSize);
return FsvolDeviceExtension->GenericTableElementStorage;
return DeviceExtension->GenericTableElementStorage;
}
static VOID NTAPI FspFsvolDeviceFreeElement(
static VOID NTAPI FspDeviceFreeElement(
PRTL_AVL_TABLE Table, PVOID Buffer)
{
PAGED_CODE();
}
static NTSTATUS FspFsvolDeviceInit(PDEVICE_OBJECT DeviceObject)
{
PAGED_CODE();
NTSTATUS Result;
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
/* allocate a spare VPB in case we are mounted on an fsvrt */
if (FILE_DEVICE_DISK_FILE_SYSTEM == DeviceObject->DeviceType)
{
FsvolDeviceExtension->SwapVpb = FspAllocNonPagedExternal(sizeof *FsvolDeviceExtension->SwapVpb);
if (0 == FsvolDeviceExtension->SwapVpb)
return STATUS_INSUFFICIENT_RESOURCES;
RtlZeroMemory(FsvolDeviceExtension->SwapVpb, sizeof *FsvolDeviceExtension->SwapVpb);
}
/* setup our Ioq and expiration fields */
FspIoqInitialize(&FsvolDeviceExtension->Ioq, FspIopCompleteCanceledIrp);
KeInitializeSpinLock(&FsvolDeviceExtension->ExpirationLock);
ExInitializeWorkItem(&FsvolDeviceExtension->ExpirationWorkItem,
FspFsvolDeviceExpirationRoutine, DeviceObject);
/* initialize our timer routine */
Result = IoInitializeTimer(DeviceObject, FspFsvolDeviceTimerRoutine, 0);
if (!NT_SUCCESS(Result))
return Result;
return STATUS_SUCCESS;
}
static VOID FspFsvolDeviceInitComplete(PDEVICE_OBJECT DeviceObject)
{
PAGED_CODE();
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
/*
* Reference the virtual volume device so that it will not go away while we are using it.
*/
if (0 != FsvolDeviceExtension->FsvrtDeviceObject)
ObReferenceObject(FsvolDeviceExtension->FsvrtDeviceObject);
/* start our expiration timer */
IoStartTimer(DeviceObject);
}
static VOID FspFsvolDeviceFini(PDEVICE_OBJECT DeviceObject)
{
PAGED_CODE();
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
/*
* First things first: stop our timer.
*
* Our IoTimer routine will NOT be called again after IoStopTimer() returns.
* However a work item may be in flight. For this reason our IoTimer routine
* does an ObReferenceObject() on our DeviceObject before queueing work items.
*/
IoStopTimer(DeviceObject);
/*
* Dereference the virtual volume device so that it can now go away.
*/
if (0 != FsvolDeviceExtension->FsvrtDeviceObject)
ObDereferenceObject(FsvolDeviceExtension->FsvrtDeviceObject);
/* free the spare VPB if we still have it */
if (0 != FsvolDeviceExtension->SwapVpb)
FspFreeExternal(FsvolDeviceExtension->SwapVpb);
}
static VOID FspFsvolDeviceTimerRoutine(PDEVICE_OBJECT DeviceObject, PVOID Context)
{
// !PAGED_CODE();
/*
* This routine runs at DPC level. Reference our DeviceObject and queue a work item
* so that we can do our processing at Passive level. Only do so if the work item
* is not already in flight (otherwise we could requeue the same work item).
*/
ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
KeAcquireSpinLockAtDpcLevel(&FsvolDeviceExtension->ExpirationLock);
if (!FsvolDeviceExtension->ExpirationInProgress)
{
FsvolDeviceExtension->ExpirationInProgress = TRUE;
ObReferenceObject(DeviceObject);
ExQueueWorkItem(&FsvolDeviceExtension->ExpirationWorkItem, DelayedWorkQueue);
}
KeReleaseSpinLockFromDpcLevel(&FsvolDeviceExtension->ExpirationLock);
}
static VOID FspFsvolDeviceExpirationRoutine(PVOID Context)
{
// !PAGED_CODE();
PDEVICE_OBJECT DeviceObject = Context;
if (FspDeviceRetain(DeviceObject))
try
{
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
LARGE_INTEGER Timeout;
KIRQL Irql;
Timeout.QuadPart = FsvolDeviceExtension->VolumeParams.IrpTimeout * 10000;
/* convert millis to nanos */
FspIoqRemoveExpired(&FsvolDeviceExtension->Ioq, &Timeout);
KeAcquireSpinLock(&FsvolDeviceExtension->ExpirationLock, &Irql);
FsvolDeviceExtension->ExpirationInProgress = FALSE;
KeReleaseSpinLock(&FsvolDeviceExtension->ExpirationLock, Irql);
}
finally
{
FspDeviceRelease(DeviceObject);
}
ObDereferenceObject(DeviceObject);
}
NTSTATUS FspDeviceCopyList(
PDEVICE_OBJECT **PDeviceObjects, PULONG PDeviceObjectCount)
{

22
src/sys/dirctl.c
View File

@@ -8,13 +8,13 @@
static NTSTATUS FspFsvolDirectoryControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolDirectoryControlComplete;
FSP_DRIVER_DISPATCH FspDirectoryControl;
FSP_IOCMPL_DISPATCH FspDirectoryControlComplete;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFsvolDirectoryControl)
#pragma alloc_text(PAGE, FspFsvolDirectoryControlComplete)
#pragma alloc_text(PAGE, FspDirectoryControl)
#pragma alloc_text(PAGE, FspDirectoryControlComplete)
#endif
static NTSTATUS FspFsvolDirectoryControl(
@@ -25,13 +25,19 @@ static NTSTATUS FspFsvolDirectoryControl(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolDirectoryControlComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
NTSTATUS FspDirectoryControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_DIRECTORY_CONTROL == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -42,11 +48,3 @@ NTSTATUS FspDirectoryControl(
FSP_LEAVE_MJ("%s", "");
}
VOID FspDirectoryControlComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}

49
src/sys/driver.c
View File

@@ -58,7 +58,6 @@ NTSTATUS DriverEntry(
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = FspDirectoryControl;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = FspFileSystemControl;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = FspDeviceControl;
DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = FspInternalDeviceControl;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = FspShutdown;
DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = FspLockControl;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = FspCleanup;
@@ -71,24 +70,23 @@ NTSTATUS DriverEntry(
/* setup the I/O completion functions */
FspIopCompleteFunction[IRP_MJ_CREATE] = FspFsvolCreateComplete;
FspIopCompleteFunction[IRP_MJ_CLOSE] = FspFsvolCloseComplete;
FspIopCompleteFunction[IRP_MJ_READ] = FspReadComplete;
FspIopCompleteFunction[IRP_MJ_WRITE] = FspWriteComplete;
FspIopCompleteFunction[IRP_MJ_QUERY_INFORMATION] = FspQueryInformationComplete;
FspIopCompleteFunction[IRP_MJ_SET_INFORMATION] = FspSetInformationComplete;
FspIopCompleteFunction[IRP_MJ_QUERY_EA] = FspQueryEaComplete;
FspIopCompleteFunction[IRP_MJ_SET_EA] = FspSetEaComplete;
FspIopCompleteFunction[IRP_MJ_FLUSH_BUFFERS] = FspFlushBuffersComplete;
FspIopCompleteFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = FspQueryVolumeInformationComplete;
FspIopCompleteFunction[IRP_MJ_SET_VOLUME_INFORMATION] = FspSetVolumeInformationComplete;
FspIopCompleteFunction[IRP_MJ_DIRECTORY_CONTROL] = FspDirectoryControlComplete;
FspIopCompleteFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = FspFileSystemControlComplete;
FspIopCompleteFunction[IRP_MJ_DEVICE_CONTROL] = FspDeviceControlComplete;
FspIopCompleteFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = FspFsvolInternalDeviceControlComplete;
FspIopCompleteFunction[IRP_MJ_SHUTDOWN] = FspShutdownComplete;
FspIopCompleteFunction[IRP_MJ_LOCK_CONTROL] = FspLockControlComplete;
FspIopCompleteFunction[IRP_MJ_READ] = FspFsvolReadComplete;
FspIopCompleteFunction[IRP_MJ_WRITE] = FspFsvolWriteComplete;
FspIopCompleteFunction[IRP_MJ_QUERY_INFORMATION] = FspFsvolQueryInformationComplete;
FspIopCompleteFunction[IRP_MJ_SET_INFORMATION] = FspFsvolSetInformationComplete;
FspIopCompleteFunction[IRP_MJ_QUERY_EA] = FspFsvolQueryEaComplete;
FspIopCompleteFunction[IRP_MJ_SET_EA] = FspFsvolSetEaComplete;
FspIopCompleteFunction[IRP_MJ_FLUSH_BUFFERS] = FspFsvolFlushBuffersComplete;
FspIopCompleteFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = FspFsvolQueryVolumeInformationComplete;
FspIopCompleteFunction[IRP_MJ_SET_VOLUME_INFORMATION] = FspFsvolSetVolumeInformationComplete;
FspIopCompleteFunction[IRP_MJ_DIRECTORY_CONTROL] = FspFsvolDirectoryControlComplete;
FspIopCompleteFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = FspFsvolFileSystemControlComplete;
FspIopCompleteFunction[IRP_MJ_DEVICE_CONTROL] = FspFsvolDeviceControlComplete;
FspIopCompleteFunction[IRP_MJ_SHUTDOWN] = FspFsvolShutdownComplete;
FspIopCompleteFunction[IRP_MJ_LOCK_CONTROL] = FspFsvolLockControlComplete;
FspIopCompleteFunction[IRP_MJ_CLEANUP] = FspFsvolCleanupComplete;
FspIopCompleteFunction[IRP_MJ_QUERY_SECURITY] = FspQuerySecurityComplete;
FspIopCompleteFunction[IRP_MJ_SET_SECURITY] = FspSetSecurityComplete;
FspIopCompleteFunction[IRP_MJ_QUERY_SECURITY] = FspFsvolQuerySecurityComplete;
FspIopCompleteFunction[IRP_MJ_SET_SECURITY] = FspFsvolSetSecurityComplete;
/* setup fast I/O and resource acquisition */
static FAST_IO_DISPATCH FspFastIoDispatch = { 0 };
@@ -124,18 +122,15 @@ NTSTATUS DriverEntry(
DriverObject->FastIoDispatch = &FspFastIoDispatch;
/*
* Register our devices as file systems. We do this here to simplify file system
* registration/unregistration, although this makes our driver unloadable from the
* get go.
* Register our "disk" device as a file system. We do not register our "net" device
* as a file system, but we register with the MUP instead at a later time.
*
* Unfortunately a call to IoRegisterFileSystem(), even if followed by a call to
* IoUnregistreFileSystem(), makes the driver unloadable. We attempted to move
* the register/unregister calls to FspFsctlDeviceVolume{Created,Deleted}, but it
* did not make any difference with regards to making the driver unloadable. Hence
* we stick to the simpler scheme of doing registration here.
* Please note that the call below makes our driver unloadable. In fact the driver
* remains unloadable even if we issue an IoUnregisterFileSystem() call immediately
* after our IoRegisterFileSystem() call! Some system component appears to keep an
* extra reference to our device somewhere.
*/
IoRegisterFileSystem(FspFsctlDiskDeviceObject);
IoRegisterFileSystem(FspFsctlNetDeviceObject);
#pragma prefast(suppress:28175, "We are in DriverEntry: ok to access DriverName")
FSP_LEAVE("DriverName=\"%wZ\", RegistryPath=\"%wZ\"",

257
src/sys/driver.h
View File

@@ -13,6 +13,10 @@
#include <wdmsec.h>
#include <winfsp/fsctl.h>
/* disable warnings */
#pragma warning(disable:4100) /* unreferenced formal parameter */
#pragma warning(disable:4200) /* zero-sized array in struct/union */
#define DRIVER_NAME "WinFsp"
/* IoCreateDeviceSecure default SDDL's */
@@ -21,6 +25,11 @@
#define FSP_FSVRT_DEVICE_SDDL "D:P(A;;GA;;;SY)(A;;GA;;;BA)(A;;GR;;;WD)"
/* System:GENERIC_ALL, Administrators:GENERIC_ALL, World:GENERIC_READ */
/* misc macros */
#define FSP_ALLOC_INTERNAL_TAG 'IpsF'
#define FSP_ALLOC_EXTERNAL_TAG 'XpsF'
#define FSP_IO_INCREMENT IO_NETWORK_INCREMENT
/* DEBUGLOG */
#if DBG
#define DEBUGLOG(fmt, ...) \
@@ -111,15 +120,12 @@
if (0 == (IrpSp->Control & SL_PENDING_RETURNED))\
{ \
/* if the IRP has not been marked pending already */\
ASSERT(FspFsvolDeviceExtensionKind == FspDeviceExtension(DeviceObject)->Kind);\
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension =\
FspFsvolDeviceExtension(DeviceObject);\
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension =\
FspFsvrtDeviceExtension(FsvolDeviceExtension->FsvrtDeviceObject);\
if (!FspIoqPostIrp(&FsvrtDeviceExtension->Ioq, Irp))\
if (!FspIoqPostIrp(&FsvolDeviceExtension->Ioq, Irp))\
{ \
/* this can only happen if the Ioq was stopped */\
ASSERT(FspIoqStopped(&FsvrtDeviceExtension->Ioq));\
ASSERT(FspIoqStopped(&FsvolDeviceExtension->Ioq));\
FspIopCompleteIrp(Irp, Result = STATUS_CANCELLED);\
} \
} \
@@ -166,15 +172,6 @@
goto fsp_leave_label; \
} while (0,0)
/* misc macros */
#define FSP_ALLOC_INTERNAL_TAG 'IpsF'
#define FSP_ALLOC_EXTERNAL_TAG 'XpsF'
#define FSP_IO_INCREMENT IO_NETWORK_INCREMENT
/* disable warnings */
#pragma warning(disable:4100) /* unreferenced formal parameter */
#pragma warning(disable:4200) /* zero-sized array in struct/union */
/* driver major functions */
_Function_class_(DRIVER_DISPATCH)
_IRQL_requires_max_(APC_LEVEL)
@@ -189,7 +186,6 @@ _Dispatch_type_(IRP_MJ_DEVICE_CONTROL) FSP_DRIVER_DISPATCH FspDeviceControl;
_Dispatch_type_(IRP_MJ_DIRECTORY_CONTROL) FSP_DRIVER_DISPATCH FspDirectoryControl;
_Dispatch_type_(IRP_MJ_FILE_SYSTEM_CONTROL) FSP_DRIVER_DISPATCH FspFileSystemControl;
_Dispatch_type_(IRP_MJ_FLUSH_BUFFERS) FSP_DRIVER_DISPATCH FspFlushBuffers;
_Dispatch_type_(IRP_MJ_INTERNAL_DEVICE_CONTROL) FSP_DRIVER_DISPATCH FspInternalDeviceControl;
_Dispatch_type_(IRP_MJ_LOCK_CONTROL) FSP_DRIVER_DISPATCH FspLockControl;
_Dispatch_type_(IRP_MJ_QUERY_EA) FSP_DRIVER_DISPATCH FspQueryEa;
_Dispatch_type_(IRP_MJ_QUERY_INFORMATION) FSP_DRIVER_DISPATCH FspQueryInformation;
@@ -216,28 +212,25 @@ FSP_IOPREP_DISPATCH FspFsvolCreatePrepare;
FSP_IOCMPL_DISPATCH FspFsvolCleanupComplete;
FSP_IOCMPL_DISPATCH FspFsvolCloseComplete;
FSP_IOCMPL_DISPATCH FspFsvolCreateComplete;
FSP_IOCMPL_DISPATCH FspDeviceControlComplete;
FSP_IOCMPL_DISPATCH FspDirectoryControlComplete;
FSP_IOCMPL_DISPATCH FspFileSystemControlComplete;
FSP_IOCMPL_DISPATCH FspFlushBuffersComplete;
FSP_IOCMPL_DISPATCH FspFsvolInternalDeviceControlComplete;
FSP_IOCMPL_DISPATCH FspLockControlComplete;
FSP_IOCMPL_DISPATCH FspQueryEaComplete;
FSP_IOCMPL_DISPATCH FspQueryInformationComplete;
FSP_IOCMPL_DISPATCH FspQuerySecurityComplete;
FSP_IOCMPL_DISPATCH FspQueryVolumeInformationComplete;
FSP_IOCMPL_DISPATCH FspReadComplete;
FSP_IOCMPL_DISPATCH FspSetEaComplete;
FSP_IOCMPL_DISPATCH FspSetInformationComplete;
FSP_IOCMPL_DISPATCH FspSetSecurityComplete;
FSP_IOCMPL_DISPATCH FspSetVolumeInformationComplete;
FSP_IOCMPL_DISPATCH FspShutdownComplete;
FSP_IOCMPL_DISPATCH FspWriteComplete;
FSP_IOCMPL_DISPATCH FspFsvolDeviceControlComplete;
FSP_IOCMPL_DISPATCH FspFsvolDirectoryControlComplete;
FSP_IOCMPL_DISPATCH FspFsvolFileSystemControlComplete;
FSP_IOCMPL_DISPATCH FspFsvolFlushBuffersComplete;
FSP_IOCMPL_DISPATCH FspFsvolLockControlComplete;
FSP_IOCMPL_DISPATCH FspFsvolQueryEaComplete;
FSP_IOCMPL_DISPATCH FspFsvolQueryInformationComplete;
FSP_IOCMPL_DISPATCH FspFsvolQuerySecurityComplete;
FSP_IOCMPL_DISPATCH FspFsvolQueryVolumeInformationComplete;
FSP_IOCMPL_DISPATCH FspFsvolReadComplete;
FSP_IOCMPL_DISPATCH FspFsvolSetEaComplete;
FSP_IOCMPL_DISPATCH FspFsvolSetInformationComplete;
FSP_IOCMPL_DISPATCH FspFsvolSetSecurityComplete;
FSP_IOCMPL_DISPATCH FspFsvolSetVolumeInformationComplete;
FSP_IOCMPL_DISPATCH FspFsvolShutdownComplete;
FSP_IOCMPL_DISPATCH FspFsvolWriteComplete;
/* fast I/O */
/* fast I/O and resource acquisition */
FAST_IO_CHECK_IF_POSSIBLE FspFastIoCheckIfPossible;
/* resource acquisition */
FAST_IO_ACQUIRE_FILE FspAcquireFileForNtCreateSection;
FAST_IO_RELEASE_FILE FspReleaseFileForNtCreateSection;
FAST_IO_ACQUIRE_FOR_MOD_WRITE FspAcquireForModWrite;
@@ -245,6 +238,52 @@ FAST_IO_RELEASE_FOR_MOD_WRITE FspReleaseForModWrite;
FAST_IO_ACQUIRE_FOR_CCFLUSH FspAcquireForCcFlush;
FAST_IO_RELEASE_FOR_CCFLUSH FspReleaseForCcFlush;
/* memory allocation */
static inline
PVOID FspAlloc(SIZE_T Size)
{
return ExAllocatePoolWithTag(PagedPool, Size, FSP_ALLOC_INTERNAL_TAG);
}
static inline
PVOID FspAllocNonPaged(SIZE_T Size)
{
return ExAllocatePoolWithTag(NonPagedPool, Size, FSP_ALLOC_INTERNAL_TAG);
}
static inline
VOID FspFree(PVOID Pointer)
{
ExFreePoolWithTag(Pointer, FSP_ALLOC_INTERNAL_TAG);
}
static inline
PVOID FspAllocExternal(SIZE_T Size)
{
return ExAllocatePoolWithTag(PagedPool, Size, FSP_ALLOC_EXTERNAL_TAG);
}
static inline
PVOID FspAllocNonPagedExternal(SIZE_T Size)
{
return ExAllocatePoolWithTag(NonPagedPool, Size, FSP_ALLOC_EXTERNAL_TAG);
}
static inline
VOID FspFreeExternal(PVOID Pointer)
{
ExFreePool(Pointer);
}
/* utility: GUIDs */
NTSTATUS FspCreateGuid(GUID *Guid);
/* utility: delayed work queue */
typedef struct
{
KTIMER Timer;
KDPC Dpc;
WORK_QUEUE_ITEM WorkQueueItem;
} FSP_WORK_ITEM_WITH_DELAY;
VOID FspInitializeWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem,
PWORKER_THREAD_ROUTINE Routine, PVOID Context);
VOID FspQueueWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem, LARGE_INTEGER Timeout);
/* IRP context */
#define FspIrpTimestamp(Irp) \
(*(ULONGLONG *)&(Irp)->Tail.Overlay.DriverContext[0])
@@ -261,8 +300,9 @@ typedef struct
KEVENT PendingIrpEvent;
LIST_ENTRY PendingIrpList, ProcessIrpList;
IO_CSQ PendingIoCsq, ProcessIoCsq;
VOID (*CompleteCanceledIrp)(PIRP Irp);
} FSP_IOQ;
VOID FspIoqInitialize(FSP_IOQ *Ioq);
VOID FspIoqInitialize(FSP_IOQ *Ioq, VOID (*CompleteCanceledIrp)(PIRP Irp));
VOID FspIoqStop(FSP_IOQ *Ioq);
BOOLEAN FspIoqStopped(FSP_IOQ *Ioq);
VOID FspIoqRemoveExpired(FSP_IOQ *Ioq, PLARGE_INTEGER Timeout);
@@ -289,10 +329,21 @@ VOID FspIopCompleteIrp(PIRP Irp, NTSTATUS Result)
{
FspIopCompleteIrpEx(Irp, Result, TRUE);
}
VOID FspIopCompleteCanceledIrp(PIRP Irp);
NTSTATUS FspIopDispatchPrepare(PIRP Irp, FSP_FSCTL_TRANSACT_REQ *Request);
VOID FspIopDispatchComplete(PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response);
/* device management */
typedef struct
{
UINT64 Identifier;
PVOID Context;
} FSP_DEVICE_GENERIC_TABLE_ELEMENT_DATA;
typedef struct
{
RTL_BALANCED_LINKS Header;
FSP_DEVICE_GENERIC_TABLE_ELEMENT_DATA Data;
} FSP_DEVICE_GENERIC_TABLE_ELEMENT;
enum
{
FspFsctlDeviceExtensionKind = '\0ltC', /* file system control device (e.g. \Device\WinFsp.Disk) */
@@ -304,62 +355,32 @@ typedef struct
KSPIN_LOCK SpinLock;
LONG RefCount;
ERESOURCE Resource;
RTL_AVL_TABLE GenericTable;
PVOID GenericTableElementStorage;
UINT32 Kind;
} FSP_DEVICE_EXTENSION;
typedef struct
{
FSP_DEVICE_EXTENSION Base;
ULONG FsvrtDeviceObjectCount;
} FSP_FSCTL_DEVICE_EXTENSION;
typedef struct
{
FSP_DEVICE_EXTENSION Base;
PDEVICE_OBJECT FsctlDeviceObject;
PDEVICE_OBJECT FsvolDeviceObject;
PDEVICE_OBJECT FsvrtDeviceObject;
HANDLE MupHandle;
BOOLEAN DeletePending;
FSP_WORK_ITEM_WITH_DELAY DeleteVolumeWorkItem;
FSP_DEVICE_GENERIC_TABLE_ELEMENT ElementStorage;
FSP_FSCTL_VOLUME_PARAMS VolumeParams;
PVPB SwapVpb;
FSP_IOQ Ioq;
KSPIN_LOCK ExpirationLock;
WORK_QUEUE_ITEM ExpirationWorkItem;
BOOLEAN ExpirationInProgress;
PVPB SwapVpb;
BOOLEAN Deleted;
FSP_FSCTL_DECLSPEC_ALIGN UINT8 SecurityDescriptorBuf[];
} FSP_FSVRT_DEVICE_EXTENSION;
typedef struct
{
FSP_DEVICE_EXTENSION Base;
PDEVICE_OBJECT FsvrtDeviceObject;
RTL_AVL_TABLE GenericTable;
PVOID GenericTableElementStorage;
} FSP_FSVOL_DEVICE_EXTENSION;
typedef struct
{
UINT64 Identifier;
PVOID Context;
} FSP_DEVICE_GENERIC_TABLE_ELEMENT_DATA;
typedef struct
{
RTL_BALANCED_LINKS Header;
FSP_DEVICE_GENERIC_TABLE_ELEMENT_DATA Data;
} FSP_DEVICE_GENERIC_TABLE_ELEMENT;
static inline
FSP_DEVICE_EXTENSION *FspDeviceExtension(PDEVICE_OBJECT DeviceObject)
{
return DeviceObject->DeviceExtension;
}
static inline
FSP_FSCTL_DEVICE_EXTENSION *FspFsctlDeviceExtension(PDEVICE_OBJECT DeviceObject)
{
ASSERT(FspFsctlDeviceExtensionKind == ((FSP_DEVICE_EXTENSION *)DeviceObject->DeviceExtension)->Kind);
return DeviceObject->DeviceExtension;
}
static inline
FSP_FSVRT_DEVICE_EXTENSION *FspFsvrtDeviceExtension(PDEVICE_OBJECT DeviceObject)
{
ASSERT(FspFsvrtDeviceExtensionKind == ((FSP_DEVICE_EXTENSION *)DeviceObject->DeviceExtension)->Kind);
return DeviceObject->DeviceExtension;
}
static inline
FSP_FSVOL_DEVICE_EXTENSION *FspFsvolDeviceExtension(PDEVICE_OBJECT DeviceObject)
{
ASSERT(FspFsvolDeviceExtensionKind == ((FSP_DEVICE_EXTENSION *)DeviceObject->DeviceExtension)->Kind);
@@ -376,12 +397,10 @@ VOID FspDeviceInitComplete(PDEVICE_OBJECT DeviceObject);
VOID FspDeviceDelete(PDEVICE_OBJECT DeviceObject);
BOOLEAN FspDeviceRetain(PDEVICE_OBJECT DeviceObject);
VOID FspDeviceRelease(PDEVICE_OBJECT DeviceObject);
VOID FspFsctlDeviceVolumeCreated(PDEVICE_OBJECT DeviceObject);
VOID FspFsctlDeviceVolumeDeleted(PDEVICE_OBJECT DeviceObject);
PVOID FspFsvolDeviceLookupContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier);
PVOID FspFsvolDeviceInsertContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier, PVOID Context,
PVOID FspDeviceLookupContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier);
PVOID FspDeviceInsertContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier, PVOID Context,
FSP_DEVICE_GENERIC_TABLE_ELEMENT *ElementStorage, PBOOLEAN PInserted);
VOID FspFsvolDeviceDeleteContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier,
VOID FspDeviceDeleteContext(PDEVICE_OBJECT DeviceObject, UINT64 Identifier,
PBOOLEAN PDeleted);
NTSTATUS FspDeviceCopyList(
PDEVICE_OBJECT **PDeviceObjects, PULONG PDeviceObjectCount);
@@ -389,6 +408,23 @@ VOID FspDeviceDeleteList(
PDEVICE_OBJECT *DeviceObjects, ULONG DeviceObjectCount);
VOID FspDeviceDeleteAll(VOID);
/* debug */
#if DBG
BOOLEAN HasDbgBreakPoint(const char *Function);
const char *NtStatusSym(NTSTATUS Status);
const char *IrpMajorFunctionSym(UCHAR MajorFunction);
const char *IrpMinorFunctionSym(UCHAR MajorFunction, UCHAR MinorFunction);
const char *IoctlCodeSym(ULONG ControlCode);
#endif
/* extern */
extern PDRIVER_OBJECT FspDriverObject;
extern PDEVICE_OBJECT FspFsctlDiskDeviceObject;
extern PDEVICE_OBJECT FspFsctlNetDeviceObject;
extern FSP_IOPREP_DISPATCH *FspIopPrepareFunction[];
extern FSP_IOCMPL_DISPATCH *FspIopCompleteFunction[];
#if 0
/* file objects */
#define FspFileContextKind(FsContext) \
(((FSP_FILE_CONTEXT *)FsContext)->Header.NodeTypeCode)
@@ -451,69 +487,6 @@ VOID FspFileContextRelease(FSP_FILE_CONTEXT *Context)
FspFileContextDelete(Context);
}
/* misc */
static inline
PVOID FspAlloc(SIZE_T Size)
{
return ExAllocatePoolWithTag(PagedPool, Size, FSP_ALLOC_INTERNAL_TAG);
}
static inline
PVOID FspAllocNonPaged(SIZE_T Size)
{
return ExAllocatePoolWithTag(NonPagedPool, Size, FSP_ALLOC_INTERNAL_TAG);
}
static inline
VOID FspFree(PVOID Pointer)
{
ExFreePoolWithTag(Pointer, FSP_ALLOC_INTERNAL_TAG);
}
static inline
PVOID FspAllocExternal(SIZE_T Size)
{
return ExAllocatePoolWithTag(PagedPool, Size, FSP_ALLOC_EXTERNAL_TAG);
}
static inline
PVOID FspAllocNonPagedExternal(SIZE_T Size)
{
return ExAllocatePoolWithTag(NonPagedPool, Size, FSP_ALLOC_EXTERNAL_TAG);
}
static inline
VOID FspFreeExternal(PVOID Pointer)
{
ExFreePool(Pointer);
}
NTSTATUS FspCreateGuid(GUID *Guid);
BOOLEAN FspValidRelativeSecurityDescriptor(
PSECURITY_DESCRIPTOR SecurityDescriptor, ULONG SecurityDescriptorLength,
SECURITY_INFORMATION RequiredInformation);
NTSTATUS FspSecuritySubjectContextAccessCheck(
PSECURITY_DESCRIPTOR SecurityDescriptor, ACCESS_MASK DesiredAccess, KPROCESSOR_MODE AccessMode);
/* delayed work queue */
typedef struct
{
KTIMER Timer;
KDPC Dpc;
WORK_QUEUE_ITEM WorkQueueItem;
} FSP_WORK_ITEM_WITH_DELAY;
VOID FspInitializeWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem,
PWORKER_THREAD_ROUTINE Routine, PVOID Context);
VOID FspQueueWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem, LARGE_INTEGER Timeout);
/* debug */
#if DBG
BOOLEAN HasDbgBreakPoint(const char *Function);
const char *NtStatusSym(NTSTATUS Status);
const char *IrpMajorFunctionSym(UCHAR MajorFunction);
const char *IrpMinorFunctionSym(UCHAR MajorFunction, UCHAR MinorFunction);
const char *IoctlCodeSym(ULONG ControlCode);
#endif
/* extern */
extern PDRIVER_OBJECT FspDriverObject;
extern PDEVICE_OBJECT FspFsctlDiskDeviceObject;
extern PDEVICE_OBJECT FspFsctlNetDeviceObject;
extern FSP_IOPREP_DISPATCH *FspIopPrepareFunction[];
extern FSP_IOCMPL_DISPATCH *FspIopCompleteFunction[];
#endif

44
src/sys/ea.c
View File

@@ -8,20 +8,20 @@
static NTSTATUS FspFsvolQueryEa(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolQueryEaComplete;
static NTSTATUS FspFsvolSetEa(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolSetEaComplete;
FSP_DRIVER_DISPATCH FspQueryEa;
FSP_DRIVER_DISPATCH FspSetEa;
FSP_IOCMPL_DISPATCH FspQueryEaComplete;
FSP_IOCMPL_DISPATCH FspSetEaComplete;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFsvolQueryEa)
#pragma alloc_text(PAGE, FspFsvolQueryEaComplete)
#pragma alloc_text(PAGE, FspFsvolSetEa)
#pragma alloc_text(PAGE, FspFsvolSetEaComplete)
#pragma alloc_text(PAGE, FspQueryEa)
#pragma alloc_text(PAGE, FspSetEa)
#pragma alloc_text(PAGE, FspQueryEaComplete)
#pragma alloc_text(PAGE, FspSetEaComplete)
#endif
static NTSTATUS FspFsvolQueryEa(
@@ -32,6 +32,14 @@ static NTSTATUS FspFsvolQueryEa(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolQueryEaComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
static NTSTATUS FspFsvolSetEa(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
@@ -40,13 +48,19 @@ static NTSTATUS FspFsvolSetEa(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolSetEaComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
NTSTATUS FspQueryEa(
PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_QUERY_EA == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -63,8 +77,6 @@ NTSTATUS FspSetEa(
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_SET_EA == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -75,19 +87,3 @@ NTSTATUS FspSetEa(
FSP_LEAVE_MJ("%s", "");
}
VOID FspQueryEaComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
VOID FspSetEaComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}

75
src/sys/fastio.c
View File

@@ -7,9 +7,21 @@
#include <sys/driver.h>
FAST_IO_CHECK_IF_POSSIBLE FspFastIoCheckIfPossible;
FAST_IO_ACQUIRE_FILE FspAcquireFileForNtCreateSection;
FAST_IO_RELEASE_FILE FspReleaseFileForNtCreateSection;
FAST_IO_ACQUIRE_FOR_MOD_WRITE FspAcquireForModWrite;
FAST_IO_RELEASE_FOR_MOD_WRITE FspReleaseForModWrite;
FAST_IO_ACQUIRE_FOR_CCFLUSH FspAcquireForCcFlush;
FAST_IO_RELEASE_FOR_CCFLUSH FspReleaseForCcFlush;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFastIoCheckIfPossible)
#pragma alloc_text(PAGE, FspAcquireFileForNtCreateSection)
#pragma alloc_text(PAGE, FspReleaseFileForNtCreateSection)
#pragma alloc_text(PAGE, FspAcquireForModWrite)
#pragma alloc_text(PAGE, FspReleaseForModWrite)
#pragma alloc_text(PAGE, FspAcquireForCcFlush)
#pragma alloc_text(PAGE, FspReleaseForCcFlush)
#endif
BOOLEAN FspFastIoCheckIfPossible(
@@ -28,3 +40,66 @@ BOOLEAN FspFastIoCheckIfPossible(
FSP_LEAVE_BOOL("%s", "");
}
VOID FspAcquireFileForNtCreateSection(
PFILE_OBJECT FileObject)
{
FSP_ENTER_VOID(PAGED_CODE());
FSP_LEAVE_VOID("%s", "");
}
VOID FspReleaseFileForNtCreateSection(
PFILE_OBJECT FileObject)
{
FSP_ENTER_VOID(PAGED_CODE());
FSP_LEAVE_VOID("%s", "");
}
NTSTATUS FspAcquireForModWrite(
PFILE_OBJECT FileObject,
PLARGE_INTEGER EndingOffset,
PERESOURCE *ResourceToRelease,
PDEVICE_OBJECT DeviceObject)
{
FSP_ENTER(PAGED_CODE());
Result = STATUS_NOT_IMPLEMENTED;
FSP_LEAVE("%s", "");
}
NTSTATUS FspReleaseForModWrite(
PFILE_OBJECT FileObject,
PERESOURCE ResourceToRelease,
PDEVICE_OBJECT DeviceObject)
{
FSP_ENTER(PAGED_CODE());
Result = STATUS_NOT_IMPLEMENTED;
FSP_LEAVE("%s", "");
}
NTSTATUS FspAcquireForCcFlush(
PFILE_OBJECT FileObject,
PDEVICE_OBJECT DeviceObject)
{
FSP_ENTER(PAGED_CODE());
Result = STATUS_NOT_IMPLEMENTED;
FSP_LEAVE("%s", "");
}
NTSTATUS FspReleaseForCcFlush(
PFILE_OBJECT FileObject,
PDEVICE_OBJECT DeviceObject)
{
FSP_ENTER(PAGED_CODE());
Result = STATUS_NOT_IMPLEMENTED;
FSP_LEAVE("%s", "");
}

44
src/sys/fileinfo.c
View File

@@ -8,20 +8,20 @@
static NTSTATUS FspFsvolQueryInformation(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolQueryInformationComplete;
static NTSTATUS FspFsvolSetInformation(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolSetInformationComplete;
FSP_DRIVER_DISPATCH FspQueryInformation;
FSP_DRIVER_DISPATCH FspSetInformation;
FSP_IOCMPL_DISPATCH FspQueryInformationComplete;
FSP_IOCMPL_DISPATCH FspSetInformationComplete;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFsvolQueryInformation)
#pragma alloc_text(PAGE, FspFsvolQueryInformationComplete)
#pragma alloc_text(PAGE, FspFsvolSetInformation)
#pragma alloc_text(PAGE, FspFsvolSetInformationComplete)
#pragma alloc_text(PAGE, FspQueryInformation)
#pragma alloc_text(PAGE, FspSetInformation)
#pragma alloc_text(PAGE, FspQueryInformationComplete)
#pragma alloc_text(PAGE, FspSetInformationComplete)
#endif
static NTSTATUS FspFsvolQueryInformation(
@@ -32,6 +32,14 @@ static NTSTATUS FspFsvolQueryInformation(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolQueryInformationComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
static NTSTATUS FspFsvolSetInformation(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
@@ -40,13 +48,19 @@ static NTSTATUS FspFsvolSetInformation(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolSetInformationComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
NTSTATUS FspQueryInformation(
PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_QUERY_INFORMATION == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -63,8 +77,6 @@ NTSTATUS FspSetInformation(
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_SET_INFORMATION == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -75,19 +87,3 @@ NTSTATUS FspSetInformation(
FSP_LEAVE_MJ("%s", "");
}
VOID FspQueryInformationComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
VOID FspSetInformationComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}

72
src/sys/fileobj.c
View File

@@ -1,72 +0,0 @@
/**
* @file sys/fileobj.c
*
* @copyright 2015 Bill Zissimopoulos
*/
#include <sys/driver.h>
NTSTATUS FspFileContextCreate(PDEVICE_OBJECT DeviceObject,
ULONG ExtraSize, FSP_FILE_CONTEXT **PFsContext);
VOID FspFileContextDelete(FSP_FILE_CONTEXT *Context);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFileContextCreate)
#pragma alloc_text(PAGE, FspFileContextDelete)
#endif
NTSTATUS FspFileContextCreate(PDEVICE_OBJECT DeviceObject,
ULONG ExtraSize, FSP_FILE_CONTEXT **PFsContext)
{
PAGED_CODE();
*PFsContext = 0;
FSP_FILE_CONTEXT_NONPAGED *NonPaged = FspAllocNonPaged(sizeof *NonPaged);
if (0 == NonPaged)
return STATUS_INSUFFICIENT_RESOURCES;
FSP_FILE_CONTEXT *FsContext = FspAlloc(sizeof *FsContext + ExtraSize);
if (0 == FsContext)
{
FspFree(NonPaged);
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(NonPaged, sizeof *NonPaged);
ExInitializeResourceLite(&NonPaged->Resource);
ExInitializeResourceLite(&NonPaged->PagingIoResource);
ExInitializeFastMutex(&NonPaged->HeaderFastMutex);
RtlZeroMemory(FsContext, sizeof *FsContext + ExtraSize);
FsContext->Header.NodeTypeCode = FspFileContextFileKind;
FsContext->Header.NodeByteSize = sizeof *FsContext;
FsContext->Header.IsFastIoPossible = FastIoIsQuestionable;
FsContext->Header.Resource = &NonPaged->Resource;
FsContext->Header.PagingIoResource = &NonPaged->PagingIoResource;
FsRtlSetupAdvancedHeader(&FsContext->Header, &NonPaged->HeaderFastMutex);
FsContext->NonPaged = NonPaged;
FsContext->RefCount = 1;
FsContext->FsvolDeviceObject = DeviceObject;
FspDeviceRetain(FsContext->FsvolDeviceObject);
RtlInitEmptyUnicodeString(&FsContext->FileName, FsContext->FileNameBuf, (USHORT)ExtraSize);
*PFsContext = FsContext;
return STATUS_SUCCESS;
}
VOID FspFileContextDelete(FSP_FILE_CONTEXT *FsContext)
{
PAGED_CODE();
FsRtlTeardownPerStreamContexts(&FsContext->Header);
FspDeviceRelease(FsContext->FsvolDeviceObject);
ExDeleteResourceLite(&FsContext->NonPaged->PagingIoResource);
ExDeleteResourceLite(&FsContext->NonPaged->Resource);
FspFree(FsContext->NonPaged);
FspFree(FsContext);
}

22
src/sys/flush.c
View File

@@ -8,13 +8,13 @@
static NTSTATUS FspFsvolFlushBuffers(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolFlushBuffersComplete;
FSP_DRIVER_DISPATCH FspFlushBuffers;
FSP_IOCMPL_DISPATCH FspFlushBuffersComplete;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFsvolFlushBuffers)
#pragma alloc_text(PAGE, FspFsvolFlushBuffersComplete)
#pragma alloc_text(PAGE, FspFlushBuffers)
#pragma alloc_text(PAGE, FspFlushBuffersComplete)
#endif
static NTSTATUS FspFsvolFlushBuffers(
@@ -25,13 +25,19 @@ static NTSTATUS FspFsvolFlushBuffers(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolFlushBuffersComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
NTSTATUS FspFlushBuffers(
PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_FLUSH_BUFFERS == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -42,11 +48,3 @@ NTSTATUS FspFlushBuffers(
FSP_LEAVE_MJ("%s", "");
}
VOID FspFlushBuffersComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}

572
src/sys/fsctl.c
View File

@@ -6,99 +6,64 @@
#include <sys/driver.h>
/*
* Overview
*
* The fsctl module provides the IOCTL interface to interact with the
* user-mode file system. The user-mode file system can use the IOCTL's
* to create new volumes, delete them (while they are live!) and transact
* with them.
*
*
* Volume Creation
*
* The creation of a new volume is performed using an FSP_FSCTL_CREATE
* IOCTL code. Creation is simple: a new device \Device\Volume{GUID} is
* created and its path is returned to the user-mode file system. The
* user-mode file system also passes a security descriptor to associate
* with the new virtual volume device so that only the creating user-mode
* file system can control the new volume.
*
*
* Volume Deletion
*
* Deletion of an existing volume is performed using FSP_FSCTL_DELETE and
* is quite a bit more involved. We must protect against the following two
* eventualities: (1) that the volume is currently in use and cannot simply
* go away, and (2) that a simultaneous mount operation is taking place
* while we are deleting the volume.
*
* To protect against the first eventuality we maintain a reference count
* on all our device extensions. Every time an MJ function is entered,
* the reference count is incremented (FspDeviceRetain). Every time
* an IRP is completed, the reference count is decremented (FspDeviceRelease).
* When the reference count reaches 0 the device is deleted using
* IoDeleteDevice. This ensures that a device will not go away while an
* IRP is being pending/processed.
*
* To protect against the second eventuality we use the lock (ERESOURCE)
* on the root Fsctl device to wrap volume deletion and attempts from the
* system to mount the same volume. We also mark the virtual volume device
* as Deleted in case we attempt to delete it (FspDeviceRelease) but we
* cannot because it is currently in use.
*
* A sticky point is our use of the Windows VPB. It is not well documented
* how one should handle this structure during forcible dismount. The fastfat
* and cdfs samples use a technique where they keep a spare VPB and they swap
* it with the volume one during forcible dismount. We do something similar.
* The issue is what to do with the old VPB, because we can delete a volume
* that is not currently being used. We check the VPB's ReferenceCount and
* we free the VPB in this case.
*
*
* Volume Transact
*
* The user-mode file system's primary interaction with the kernel-mode driver
* is by using the FSP_FSCTL_TRANSACT IOCTL code. Every virtual volume device
* maintains an FSP_IOQ (refer to ioq.c for more). When an FSP_FSCTL_TRANSACT
* arrives it first processes any responses (FSP_FSCTL_TRANSACT_RSP) that the
* user-mode file system has sent to handle requests sent to it using a prior
* FSP_FSCTL_TRANSACT. It then proceeds to handle any pending IRP requests by
* sending the corresponding requests (FSP_FSCTL_TRANSACT_REQ) to the user-
* mode file system.
*/
static NTSTATUS FspFsctlFileSystemControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
static NTSTATUS FspFsctlCreateVolume(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
static NTSTATUS FspFsctlMountVolume(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
static NTSTATUS FspFsvrtDeleteVolume(
VOID FspFsctlDeleteVolume(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
static WORKER_THREAD_ROUTINE FspFsvrtDeleteVolumeDelayed;
static NTSTATUS FspFsvrtTransact(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
static NTSTATUS FspFsctlFileSystemControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
static NTSTATUS FspFsvrtFileSystemControl(
static WORKER_THREAD_ROUTINE FspFsctlDeleteVolumeDelayed;
static NTSTATUS FspFsctlTransact(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
static NTSTATUS FspFsvolFileSystemControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolFileSystemControlComplete;
FSP_DRIVER_DISPATCH FspFileSystemControl;
FSP_IOCMPL_DISPATCH FspFileSystemControlComplete;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFsctlFileSystemControl)
#pragma alloc_text(PAGE, FspFsctlCreateVolume)
#pragma alloc_text(PAGE, FspFsctlMountVolume)
#pragma alloc_text(PAGE, FspFsvrtDeleteVolume)
#pragma alloc_text(PAGE, FspFsvrtDeleteVolumeDelayed)
#pragma alloc_text(PAGE, FspFsvrtTransact)
#pragma alloc_text(PAGE, FspFsctlFileSystemControl)
#pragma alloc_text(PAGE, FspFsvrtFileSystemControl)
#pragma alloc_text(PAGE, FspFsctlDeleteVolume)
#pragma alloc_text(PAGE, FspFsctlDeleteVolumeDelayed)
#pragma alloc_text(PAGE, FspFsctlTransact)
#pragma alloc_text(PAGE, FspFsvolFileSystemControl)
#pragma alloc_text(PAGE, FspFsvolFileSystemControlComplete)
#pragma alloc_text(PAGE, FspFileSystemControl)
#pragma alloc_text(PAGE, FspFileSystemControlComplete)
#endif
static NTSTATUS FspFsctlFileSystemControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
PAGED_CODE();
NTSTATUS Result = STATUS_INVALID_DEVICE_REQUEST;
switch (IrpSp->MinorFunction)
{
case IRP_MN_USER_FS_REQUEST:
switch (IrpSp->Parameters.FileSystemControl.FsControlCode)
{
case FSP_FSCTL_CREATE:
Result = FspFsctlCreateVolume(DeviceObject, Irp, IrpSp);
break;
case FSP_FSCTL_TRANSACT:
Result = FspFsctlTransact(DeviceObject, Irp, IrpSp);
break;
}
break;
case IRP_MN_MOUNT_VOLUME:
Result = FspFsctlMountVolume(DeviceObject, Irp, IrpSp);
break;
#if 0
case IRP_MN_VERIFY_VOLUME:
break;
#endif
}
return Result;
}
static NTSTATUS FspFsctlCreateVolume(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
@@ -108,29 +73,24 @@ static NTSTATUS FspFsctlCreateVolume(
ULONG InputBufferLength = IrpSp->Parameters.FileSystemControl.InputBufferLength;
ULONG OutputBufferLength = IrpSp->Parameters.FileSystemControl.OutputBufferLength;
PVOID SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
PSECURITY_DESCRIPTOR SecurityDescriptor =
(PVOID)((PUINT8)SystemBuffer + FSP_FSCTL_VOLUME_PARAMS_SIZE);
DWORD SecurityDescriptorSize = InputBufferLength - FSP_FSCTL_VOLUME_PARAMS_SIZE;
if (FSP_FSCTL_VOLUME_PARAMS_SIZE >= InputBufferLength || 0 == SystemBuffer ||
!FspValidRelativeSecurityDescriptor(SecurityDescriptor, SecurityDescriptorSize,
DACL_SECURITY_INFORMATION))
if (sizeof(FSP_FSCTL_VOLUME_PARAMS) > InputBufferLength || 0 == SystemBuffer)
return STATUS_INVALID_PARAMETER;
if (FSP_FSCTL_CREATE_BUFFER_SIZEMIN > OutputBufferLength)
return STATUS_BUFFER_TOO_SMALL;
NTSTATUS Result;
FSP_FSCTL_VOLUME_PARAMS VolumeParams = *(FSP_FSCTL_VOLUME_PARAMS *)SystemBuffer;
PVOID SecurityDescriptorBuf = 0;
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension;
/* check the passed in VolumeParams */
if (FspFsctlIrpTimeoutMinimum > VolumeParams.IrpTimeout ||
VolumeParams.IrpTimeout > FspFsctlIrpTimeoutMaximum)
{
#if DBG
/* allow the debug timeout value on debug builds */
if (FspFsctlIrpTimeoutDebug != VolumeParams.IrpTimeout)
#endif
VolumeParams.IrpTimeout = FspFsctlIrpTimeoutDefault;
}
if (FspFsctlTransactTimeoutMinimum > VolumeParams.TransactTimeout ||
VolumeParams.TransactTimeout > FspFsctlTransactTimeoutMaximum)
VolumeParams.TransactTimeout = FspFsctlTransactTimeoutDefault;
@@ -141,14 +101,7 @@ static NTSTATUS FspFsctlCreateVolume(
if (!NT_SUCCESS(Result))
return Result;
/* copy the security descriptor from the system buffer to a temporary one */
SecurityDescriptorBuf = FspAlloc(SecurityDescriptorSize);
if (0 == SecurityDescriptorBuf)
return STATUS_INSUFFICIENT_RESOURCES;
RtlCopyMemory(SecurityDescriptorBuf, SecurityDescriptor, SecurityDescriptorSize);
/* prepare the device name and SDDL */
PDEVICE_OBJECT FsvrtDeviceObject;
UNICODE_STRING DeviceSddl;
UNICODE_STRING DeviceName;
RtlInitUnicodeString(&DeviceSddl, L"" FSP_FSVRT_DEVICE_SDDL);
@@ -160,38 +113,81 @@ static NTSTATUS FspFsctlCreateVolume(
Guid.Data4[4], Guid.Data4[5], Guid.Data4[6], Guid.Data4[7]);
ASSERT(NT_SUCCESS(Result));
/* create the virtual volume device */
FSP_FSCTL_DEVICE_EXTENSION *FsctlDeviceExtension = FspFsctlDeviceExtension(DeviceObject);
ExAcquireResourceExclusiveLite(&FsctlDeviceExtension->Base.Resource, TRUE);
FSP_DEVICE_EXTENSION *DeviceExtension = FspDeviceExtension(DeviceObject);
ExAcquireResourceExclusiveLite(&DeviceExtension->Resource, TRUE);
try
{
Result = FspDeviceCreateSecure(FspFsvrtDeviceExtensionKind, SecurityDescriptorSize,
&DeviceName, FILE_DEVICE_VIRTUAL_DISK,
&DeviceSddl, &FspFsvrtDeviceClassGuid,
&FsvrtDeviceObject);
if (NT_SUCCESS(Result))
HANDLE MupHandle = 0;
PDEVICE_OBJECT FsvrtDeviceObject = 0;
PDEVICE_OBJECT FsvolDeviceObject;
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension;
BOOLEAN Inserted;
/* quick check to see if we already have a volume */
FsvolDeviceObject = FspDeviceLookupContext(DeviceObject, (UINT_PTR)IrpSp->FileObject);
if (0 != FsvolDeviceObject)
{
Result = STATUS_ACCESS_DENIED;
goto exit;
}
/* create the volume (and virtual disk) device(s) */
Result = FspDeviceCreate(FspFsvolDeviceExtensionKind, 0,
DeviceObject->DeviceType,
&FsvolDeviceObject);
if (!NT_SUCCESS(Result))
goto exit;
if (FILE_DEVICE_DISK_FILE_SYSTEM == DeviceObject->DeviceType)
{
Result = FspDeviceCreateSecure(FspFsvrtDeviceExtensionKind, 0,
&DeviceName, FILE_DEVICE_VIRTUAL_DISK,
&DeviceSddl, &FspFsvrtDeviceClassGuid,
&FsvrtDeviceObject);
if (!NT_SUCCESS(Result))
{
FspDeviceRelease(FsvolDeviceObject);
goto exit;
}
#pragma prefast(suppress:28175, "We are a filesystem: ok to access SectorSize")
FsvrtDeviceObject->SectorSize = VolumeParams.SectorSize;
FsvrtDeviceExtension = FspFsvrtDeviceExtension(FsvrtDeviceObject);
FsvrtDeviceExtension->FsctlDeviceObject = DeviceObject;
FsvrtDeviceExtension->VolumeParams = VolumeParams;
RtlCopyMemory(FsvrtDeviceExtension->SecurityDescriptorBuf,
SecurityDescriptorBuf, SecurityDescriptorSize);
FspDeviceInitComplete(FsvrtDeviceObject);
Irp->IoStatus.Information = DeviceName.Length + sizeof(WCHAR);
FspFsctlDeviceVolumeCreated(DeviceObject);
}
#pragma prefast(suppress:28175, "We are a filesystem: ok to access SectorSize")
FsvolDeviceObject->SectorSize = VolumeParams.SectorSize;
FsvolDeviceExtension = FspFsvolDeviceExtension(FsvolDeviceObject);
FsvolDeviceExtension->FsctlDeviceObject = DeviceObject;
FsvolDeviceExtension->FsvrtDeviceObject = FsvrtDeviceObject;
FsvolDeviceExtension->MupHandle = MupHandle;
FsvolDeviceExtension->VolumeParams = VolumeParams;
if (0 != FsvrtDeviceObject)
FspDeviceInitComplete(FsvrtDeviceObject);
FspDeviceInitComplete(FsvolDeviceObject);
/* do we need to register with MUP? */
if (0 == FsvrtDeviceObject)
{
Result = FsRtlRegisterUncProviderEx(&MupHandle, &DeviceName, FsvolDeviceObject, 0);
if (!NT_SUCCESS(Result))
{
FspDeviceRelease(FsvolDeviceObject);
goto exit;
}
}
/* associate the new volume device with our file object */
FspDeviceInsertContext(DeviceObject, (UINT_PTR)IrpSp->FileObject, FsvolDeviceObject,
&FsvolDeviceExtension->ElementStorage, &Inserted);
ASSERT(Inserted);
Irp->IoStatus.Information = DeviceName.Length + sizeof(WCHAR);
Result = STATUS_SUCCESS;
exit:;
}
finally
{
ExReleaseResourceLite(&FsctlDeviceExtension->Base.Resource);
ExReleaseResourceLite(&DeviceExtension->Resource);
}
/* free the temporary security descriptor */
if (0 != SecurityDescriptorBuf)
FspFree(SecurityDescriptorBuf);
return Result;
}
@@ -201,222 +197,182 @@ static NTSTATUS FspFsctlMountVolume(
PAGED_CODE();
NTSTATUS Result;
FSP_FSCTL_DEVICE_EXTENSION *FsctlDeviceExtension = FspFsctlDeviceExtension(DeviceObject);
ExAcquireResourceExclusiveLite(&FsctlDeviceExtension->Base.Resource, TRUE);
FSP_DEVICE_EXTENSION *DeviceExtension = FspDeviceExtension(DeviceObject);
ExAcquireResourceExclusiveLite(&DeviceExtension->Resource, TRUE);
try
{
PDEVICE_OBJECT *DeviceObjects = 0;
ULONG DeviceObjectCount = 0;
PVPB Vpb = IrpSp->Parameters.MountVolume.Vpb;
PDEVICE_OBJECT FsvrtDeviceObject = IrpSp->Parameters.MountVolume.DeviceObject;
PDEVICE_OBJECT FsvolDeviceObject;
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension =
FspFsvrtDeviceExtension(FsvrtDeviceObject);
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension;
/* check the passed in volume object; it must be one of our own and not marked Deleted */
Result = FspDeviceCopyList(&DeviceObjects, &DeviceObjectCount);
if (NT_SUCCESS(Result))
/* quick check to see if we already have a volume */
FsvolDeviceObject = FspDeviceLookupContext(DeviceObject, (UINT_PTR)IrpSp->FileObject);
if (0 != FsvolDeviceObject)
{
Result = STATUS_UNRECOGNIZED_VOLUME;
for (ULONG i = 0; DeviceObjectCount > i; i++)
if (DeviceObjects[i] == FsvrtDeviceObject)
{
if (FspDeviceRetain(FsvrtDeviceObject))
{
if (!FsvrtDeviceExtension->Deleted &&
FILE_DEVICE_VIRTUAL_DISK == FsvrtDeviceObject->DeviceType)
Result = STATUS_SUCCESS;
else
FspDeviceRelease(FsvrtDeviceObject);
}
break;
}
FspDeviceDeleteList(DeviceObjects, DeviceObjectCount);
}
if (!NT_SUCCESS(Result))
goto exit;
/* create the file system device object */
Result = FspDeviceCreate(FspFsvolDeviceExtensionKind, 0,
DeviceObject->DeviceType,
&FsvolDeviceObject);
if (NT_SUCCESS(Result))
{
/*
* Reference the virtual volume device so that it will not go away while the
* file system device object is alive!
*/
ObReferenceObject(FsvrtDeviceObject);
#pragma prefast(suppress:28175, "We are a filesystem: ok to access SectorSize")
FsvolDeviceObject->SectorSize = FsvrtDeviceExtension->VolumeParams.SectorSize;
FsvolDeviceExtension = FspFsvolDeviceExtension(FsvolDeviceObject);
FsvolDeviceExtension->FsvrtDeviceObject = FsvrtDeviceObject;
FsvrtDeviceExtension->FsvolDeviceObject = FsvolDeviceObject;
FspDeviceInitComplete(FsvolDeviceObject);
Vpb->DeviceObject = FsvolDeviceObject;
Vpb->SerialNumber = FsvrtDeviceExtension->VolumeParams.SerialNumber;
Irp->IoStatus.Information = 0;
}
FspDeviceRelease(FsvrtDeviceObject);
FsvolDeviceExtension = FspFsvolDeviceExtension(FsvolDeviceObject);
if (FsvolDeviceExtension->DeletePending ||
FsvolDeviceExtension->FsvrtDeviceObject != FsvrtDeviceObject)
{
Result = STATUS_UNRECOGNIZED_VOLUME;
goto exit;
}
Vpb->DeviceObject = FsvolDeviceObject;
Vpb->SerialNumber = FsvolDeviceExtension->VolumeParams.SerialNumber;
Irp->IoStatus.Information = 0;
Result = STATUS_SUCCESS;
exit:;
}
finally
{
ExReleaseResourceLite(&FsctlDeviceExtension->Base.Resource);
ExReleaseResourceLite(&DeviceExtension->Resource);
}
return Result;
}
typedef struct
{
PDEVICE_OBJECT FsvolDeviceObject;
PVPB OldVpb;
FSP_WORK_ITEM_WITH_DELAY WorkItemWithDelay;
} FSP_FSVRT_DELETE_VOLUME_WORK_ITEM;
static NTSTATUS FspFsvrtDeleteVolume(
VOID FspFsctlDeleteVolume(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
/* performed during IRP_MJ_CLEANUP! */
PAGED_CODE();
NTSTATUS Result;
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension = FspFsvrtDeviceExtension(DeviceObject);
FSP_FSCTL_DEVICE_EXTENSION *FsctlDeviceExtension =
FspFsctlDeviceExtension(FsvrtDeviceExtension->FsctlDeviceObject);
PDEVICE_OBJECT FsvolDeviceObject = 0;
ExAcquireResourceExclusiveLite(&FsctlDeviceExtension->Base.Resource, TRUE);
FSP_DEVICE_EXTENSION *DeviceExtension = FspDeviceExtension(DeviceObject);
ExAcquireResourceExclusiveLite(&DeviceExtension->Resource, TRUE);
try
{
PDEVICE_OBJECT FsctlDeviceObject = FsvrtDeviceExtension->FsctlDeviceObject;
PDEVICE_OBJECT FsvolDeviceObject = FsvrtDeviceExtension->FsvolDeviceObject;
PVPB OldVpb;
BOOLEAN DeleteVpb = FALSE;
BOOLEAN DeleteDelayed = FALSE;
LARGE_INTEGER DelayTimeout;
FSP_FSVRT_DELETE_VOLUME_WORK_ITEM *WorkItem = 0;
KIRQL Irql;
/* access check */
Result = FspSecuritySubjectContextAccessCheck(
FsvrtDeviceExtension->SecurityDescriptorBuf, FILE_WRITE_DATA, Irp->RequestorMode);
if (!NT_SUCCESS(Result))
goto exit;
/* pre-allocate a work item in case we need it for delayed delete */
WorkItem = FspAllocNonPaged(sizeof *WorkItem);
if (0 == WorkItem)
{
Result = STATUS_INSUFFICIENT_RESOURCES;
goto exit;
}
/* mark the virtual volume device as deleted */
FsvrtDeviceExtension->Deleted = TRUE;
/* stop the I/O queue */
FspIoqStop(&FsvrtDeviceExtension->Ioq);
/* swap the preallocated VPB */
#pragma prefast(push)
#pragma prefast(disable:28175, "We are a filesystem: ok to access Vpb")
IoAcquireVpbSpinLock(&Irql);
OldVpb = DeviceObject->Vpb;
if (0 != OldVpb && 0 != FsvrtDeviceExtension->SwapVpb)
{
DeviceObject->Vpb = FsvrtDeviceExtension->SwapVpb;
DeviceObject->Vpb->Size = sizeof *DeviceObject->Vpb;
DeviceObject->Vpb->Type = IO_TYPE_VPB;
DeviceObject->Vpb->Flags = FlagOn(OldVpb->Flags, VPB_REMOVE_PENDING);
DeviceObject->Vpb->RealDevice = OldVpb->RealDevice;
DeviceObject->Vpb->RealDevice->Vpb = DeviceObject->Vpb;
FsvrtDeviceExtension->SwapVpb = 0;
DeleteVpb = 0 == OldVpb->ReferenceCount;
DeleteDelayed = !DeleteVpb && 0 != FsvolDeviceObject;
if (DeleteDelayed)
/* keep VPB around for delayed delete */
OldVpb->ReferenceCount++;
}
IoReleaseVpbSpinLock(Irql);
if (DeleteDelayed)
/* keep fsvol around for delayed delete */
FspDeviceRetain(FsvolDeviceObject);
else if (DeleteVpb)
FspFreeExternal(OldVpb);
#pragma prefast(pop)
/* release the file system device and virtual volume objects */
FsvrtDeviceExtension->FsvolDeviceObject = 0;
FsvolDeviceObject = FspDeviceLookupContext(DeviceObject, (UINT_PTR)IrpSp->FileObject);
if (0 != FsvolDeviceObject)
FspDeviceRelease(FsvolDeviceObject);
FspDeviceRelease(DeviceObject);
FspFsctlDeviceVolumeDeleted(FsctlDeviceObject);
/* are we doing delayed delete of VPB and fsvol? */
if (DeleteDelayed)
{
DelayTimeout.QuadPart = 300/*ms*/ * -10000;
WorkItem->FsvolDeviceObject = FsvolDeviceObject;
WorkItem->OldVpb = OldVpb;
FspInitializeWorkItemWithDelay(&WorkItem->WorkItemWithDelay,
FspFsvrtDeleteVolumeDelayed, WorkItem);
FspQueueWorkItemWithDelay(&WorkItem->WorkItemWithDelay, DelayTimeout);
WorkItem = 0;
}
Result = STATUS_SUCCESS;
exit:
if (0 != WorkItem)
FspFree(WorkItem);
FspDeviceDeleteContext(DeviceObject, (UINT_PTR)IrpSp->FileObject, 0);
}
finally
{
ExReleaseResourceLite(&FsctlDeviceExtension->Base.Resource);
ExReleaseResourceLite(&DeviceExtension->Resource);
}
return Result;
if (0 != FsvolDeviceObject)
{
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(FsvolDeviceObject);
/* mark the volume device as pending delete */
FsvolDeviceExtension->DeletePending = TRUE;
/* stop the I/O queue */
FspIoqStop(&FsvolDeviceExtension->Ioq);
/* do we have a virtual disk device or a MUP handle? */
if (0 != FsvolDeviceExtension->FsvrtDeviceObject)
{
PDEVICE_OBJECT FsvrtDeviceObject = FsvolDeviceExtension->FsvrtDeviceObject;
PVPB OldVpb;
KIRQL Irql;
BOOLEAN DeleteVpb = FALSE;
BOOLEAN DeleteDelayed = FALSE;
LARGE_INTEGER DelayTimeout;
/* swap the virtual disk device VPB with the preallocated one */
#pragma prefast(push)
#pragma prefast(disable:28175, "We are a filesystem: ok to access Vpb")
IoAcquireVpbSpinLock(&Irql);
OldVpb = FsvrtDeviceObject->Vpb;
if (0 != OldVpb)
{
FsvrtDeviceObject->Vpb = FsvolDeviceExtension->SwapVpb;
FsvrtDeviceObject->Vpb->Size = sizeof *FsvrtDeviceObject->Vpb;
FsvrtDeviceObject->Vpb->Type = IO_TYPE_VPB;
FsvrtDeviceObject->Vpb->Flags = FlagOn(OldVpb->Flags, VPB_REMOVE_PENDING);
FsvrtDeviceObject->Vpb->RealDevice = OldVpb->RealDevice;
FsvrtDeviceObject->Vpb->RealDevice->Vpb = FsvrtDeviceObject->Vpb;
DeleteVpb = 0 == OldVpb->ReferenceCount;
DeleteDelayed = !DeleteVpb;
if (DeleteDelayed)
{
/* keep VPB around for delayed delete */
OldVpb->ReferenceCount++;
FsvolDeviceExtension->SwapVpb = OldVpb;
}
else
FsvolDeviceExtension->SwapVpb = 0;
}
IoReleaseVpbSpinLock(Irql);
if (DeleteDelayed)
/* keep volume device object around for delayed delete */
FspDeviceRetain(FsvolDeviceObject);
else if (DeleteVpb)
/* no more references to the old VPB; delete now! */
FspFreeExternal(OldVpb);
#pragma prefast(pop)
/* release the virtual disk and volume device objects */
FspDeviceRelease(FsvrtDeviceObject);
FspDeviceRelease(FsvolDeviceObject);
/* are we doing delayed delete of VPB and volume device object? */
if (DeleteDelayed)
{
DelayTimeout.QuadPart = 300/*ms*/ * -10000;
FspInitializeWorkItemWithDelay(&FsvolDeviceExtension->DeleteVolumeWorkItem,
FspFsctlDeleteVolumeDelayed, FsvolDeviceObject);
FspQueueWorkItemWithDelay(&FsvolDeviceExtension->DeleteVolumeWorkItem, DelayTimeout);
}
}
else if (0 != FsvolDeviceExtension->MupHandle)
{
HANDLE MupHandle = FsvolDeviceExtension->MupHandle;
FsRtlDeregisterUncProvider(MupHandle);
/* release the volume device object */
FspDeviceRelease(FsvolDeviceObject);
}
}
}
static VOID FspFsvrtDeleteVolumeDelayed(PVOID Context)
static VOID FspFsctlDeleteVolumeDelayed(PVOID Context)
{
PAGED_CODE();
FSP_FSVRT_DELETE_VOLUME_WORK_ITEM *WorkItem = Context;
PDEVICE_OBJECT FsvolDeviceObject = Context;
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(FsvolDeviceObject);
KIRQL Irql;
BOOLEAN DeleteVpb = FALSE;
LARGE_INTEGER DelayTimeout;
KIRQL Irql;
IoAcquireVpbSpinLock(&Irql);
ASSERT(0 != WorkItem->OldVpb->ReferenceCount);
DeleteVpb = 1 == WorkItem->OldVpb->ReferenceCount;
ASSERT(0 != FsvolDeviceExtension->SwapVpb->ReferenceCount);
DeleteVpb = 1 == FsvolDeviceExtension->SwapVpb->ReferenceCount;
if (DeleteVpb)
WorkItem->OldVpb->ReferenceCount = 0;
FsvolDeviceExtension->SwapVpb->ReferenceCount = 0;
IoReleaseVpbSpinLock(Irql);
if (DeleteVpb)
{
FspFreeExternal(WorkItem->OldVpb);
FspDeviceRelease(WorkItem->FsvolDeviceObject);
FspFree(WorkItem);
FspFreeExternal(FsvolDeviceExtension->SwapVpb);
FsvolDeviceExtension->SwapVpb = 0;
FspDeviceRelease(FsvolDeviceObject);
}
else
{
DelayTimeout.QuadPart = 300/*ms*/ * -10000;
FspQueueWorkItemWithDelay(&WorkItem->WorkItemWithDelay, DelayTimeout);
FspQueueWorkItemWithDelay(&FsvolDeviceExtension->DeleteVolumeWorkItem, DelayTimeout);
}
}
static NTSTATUS FspFsvrtTransact(
static NTSTATUS FspFsctlTransact(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
PAGED_CODE();
#if 0
/* check parameters */
ULONG InputBufferLength = IrpSp->Parameters.FileSystemControl.InputBufferLength;
ULONG OutputBufferLength = IrpSp->Parameters.FileSystemControl.OutputBufferLength;
@@ -518,56 +474,10 @@ static NTSTATUS FspFsvrtTransact(
Irp->IoStatus.Information = (PUINT8)Request - (PUINT8)SystemBuffer;
return STATUS_SUCCESS;
}
static NTSTATUS FspFsctlFileSystemControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
PAGED_CODE();
NTSTATUS Result = STATUS_INVALID_DEVICE_REQUEST;
switch (IrpSp->MinorFunction)
{
case IRP_MN_USER_FS_REQUEST:
switch (IrpSp->Parameters.FileSystemControl.FsControlCode)
{
case FSP_FSCTL_CREATE:
Result = FspFsctlCreateVolume(DeviceObject, Irp, IrpSp);
break;
}
break;
case IRP_MN_MOUNT_VOLUME:
Result = FspFsctlMountVolume(DeviceObject, Irp, IrpSp);
break;
#if 0
case IRP_MN_VERIFY_VOLUME:
break;
#else
return STATUS_INVALID_DEVICE_REQUEST;
#endif
}
return Result;
}
static NTSTATUS FspFsvrtFileSystemControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
PAGED_CODE();
NTSTATUS Result = STATUS_INVALID_DEVICE_REQUEST;
switch (IrpSp->MinorFunction)
{
case IRP_MN_USER_FS_REQUEST:
switch (IrpSp->Parameters.FileSystemControl.FsControlCode)
{
case FSP_FSCTL_DELETE:
Result = FspFsvrtDeleteVolume(DeviceObject, Irp, IrpSp);
break;
case FSP_FSCTL_TRANSACT:
Result = FspFsvrtTransact(DeviceObject, Irp, IrpSp);
break;
}
break;
}
return Result;
}
static NTSTATUS FspFsvolFileSystemControl(
@@ -584,19 +494,28 @@ static NTSTATUS FspFsvolFileSystemControl(
return Result;
}
VOID FspFsvolFileSystemControlComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC(
"FileObject=%p%s%s",
IrpSp->FileObject,
IRP_MN_USER_FS_REQUEST == IrpSp->MinorFunction ? ", " : "",
IRP_MN_USER_FS_REQUEST == IrpSp->MinorFunction ?
IoctlCodeSym(IrpSp->Parameters.FileSystemControl.FsControlCode) : "");
}
NTSTATUS FspFileSystemControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_FILE_SYSTEM_CONTROL == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
FSP_RETURN(Result = FspFsvolFileSystemControl(DeviceObject, Irp, IrpSp));
case FspFsvrtDeviceExtensionKind:
FSP_RETURN(Result = FspFsvrtFileSystemControl(DeviceObject, Irp, IrpSp));
case FspFsctlDeviceExtensionKind:
FSP_RETURN(Result = FspFsctlFileSystemControl(DeviceObject, Irp, IrpSp));
default:
@@ -610,16 +529,3 @@ NTSTATUS FspFileSystemControl(
IRP_MN_USER_FS_REQUEST == IrpSp->MinorFunction ?
IoctlCodeSym(IrpSp->Parameters.FileSystemControl.FsControlCode) : "");
}
VOID FspFileSystemControlComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC(
"FileObject=%p%s%s",
IrpSp->FileObject,
IRP_MN_USER_FS_REQUEST == IrpSp->MinorFunction ? ", " : "",
IRP_MN_USER_FS_REQUEST == IrpSp->MinorFunction ?
IoctlCodeSym(IrpSp->Parameters.FileSystemControl.FsControlCode) : "");
}

102
src/sys/idevctl.c
View File

@@ -1,102 +0,0 @@
/**
* @file sys/idevctl.c
*
* @copyright 2015 Bill Zissimopoulos
*/
#include <sys/driver.h>
static NTSTATUS FspFsvolInternalDeviceControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolInternalDeviceControlComplete;
FSP_DRIVER_DISPATCH FspInternalDeviceControl;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFsvolInternalDeviceControl)
#pragma alloc_text(PAGE, FspFsvolInternalDeviceControlComplete)
#pragma alloc_text(PAGE, FspInternalDeviceControl)
#endif
static NTSTATUS FspFsvolInternalDeviceControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
PAGED_CODE();
NTSTATUS Result = STATUS_INVALID_DEVICE_REQUEST;
switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
{
case FSP_FSCTL_WORK:
{
FSP_FSVOL_DEVICE_EXTENSION *FsvolDeviceExtension = FspFsvolDeviceExtension(DeviceObject);
PDEVICE_OBJECT FsvrtDeviceObject = FsvolDeviceExtension->FsvrtDeviceObject;
if (!FspDeviceRetain(FsvrtDeviceObject))
return STATUS_CANCELLED;
try
{
FSP_FSVRT_DEVICE_EXTENSION *FsvrtDeviceExtension =
FspFsvrtDeviceExtension(FsvrtDeviceObject);
FSP_FSCTL_TRANSACT_REQ *Request = IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
ASSERT(0 == Request->Hint);
/* associate the passed Request with our Irp; acquire ownership of the Request */
Request->Hint = (UINT_PTR)Irp;
FspIrpRequest(Irp) = Request;
/*
* Post the IRP to our Ioq; we do this here instead of at IRP_LEAVE_MJ time,
* so that we can disassociate the Request on failure and release ownership
* back to the caller.
*/
if (!FspIoqPostIrp(&FsvrtDeviceExtension->Ioq, Irp))
{
/* this can only happen if the Ioq was stopped */
ASSERT(FspIoqStopped(&FsvrtDeviceExtension->Ioq));
Request->Hint = 0;
FspIrpRequest(Irp) = 0;
Result = STATUS_CANCELLED;
goto exit;
}
Result = STATUS_PENDING;
exit:;
}
finally
{
FspDeviceRelease(FsvrtDeviceObject);
}
}
break;
}
return Result;
}
VOID FspFsvolInternalDeviceControlComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", IoctlCodeSym(IrpSp->Parameters.DeviceIoControl.IoControlCode));
}
NTSTATUS FspInternalDeviceControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_INTERNAL_DEVICE_CONTROL == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
FSP_RETURN(Result = FspFsvolInternalDeviceControl(DeviceObject, Irp, IrpSp));
default:
FSP_RETURN(Result = STATUS_INVALID_DEVICE_REQUEST);
}
FSP_LEAVE_MJ("%s", IoctlCodeSym(IrpSp->Parameters.DeviceIoControl.IoControlCode));
}

15
src/sys/iop.c
View File

@@ -113,10 +113,12 @@ NTSTATUS FspIopPostWorkRequest(PDEVICE_OBJECT DeviceObject, FSP_FSCTL_TRANSACT_R
}
PIO_STACK_LOCATION IrpSp = IoGetNextIrpStackLocation(Irp);
IrpSp->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
IrpSp->Parameters.DeviceIoControl.IoControlCode = FSP_FSCTL_WORK;
IrpSp->Parameters.DeviceIoControl.InputBufferLength = Request->Size;
IrpSp->Parameters.DeviceIoControl.Type3InputBuffer = Request;
Irp->RequestorMode = KernelMode;
IrpSp->MajorFunction = IRP_MJ_FILE_SYSTEM_CONTROL;
IrpSp->MinorFunction = IRP_MN_USER_FS_REQUEST;
IrpSp->Parameters.FileSystemControl.FsControlCode = FSP_FSCTL_WORK;
IrpSp->Parameters.FileSystemControl.InputBufferLength = Request->Size;
IrpSp->Parameters.FileSystemControl.Type3InputBuffer = Request;
ASSERT(METHOD_NEITHER == (IrpSp->Parameters.DeviceIoControl.IoControlCode & 3));
@@ -170,6 +172,11 @@ VOID FspIopCompleteIrpEx(PIRP Irp, NTSTATUS Result, BOOLEAN DeviceRelease)
FspDeviceRelease(DeviceObject);
}
VOID FspIopCompleteCanceledIrp(PIRP Irp)
{
FspIopCompleteIrpEx(Irp, STATUS_CANCELLED, TRUE);
}
NTSTATUS FspIopDispatchPrepare(PIRP Irp, FSP_FSCTL_TRANSACT_REQ *Request)
{
PAGED_CODE();

19
src/sys/ioq.c
View File

@@ -120,7 +120,8 @@ static VOID FspIoqPendingReleaseLock(PIO_CSQ IoCsq, _IRQL_restores_ KIRQL Irql)
static VOID FspIoqPendingCompleteCanceledIrp(PIO_CSQ IoCsq, PIRP Irp)
{
FspIopCompleteIrp(Irp, STATUS_CANCELLED);
FSP_IOQ *Ioq = CONTAINING_RECORD(IoCsq, FSP_IOQ, PendingIoCsq);
Ioq->CompleteCanceledIrp(Irp);
}
static NTSTATUS FspIoqProcessInsertIrpEx(PIO_CSQ IoCsq, PIRP Irp, PVOID InsertContext)
@@ -183,11 +184,14 @@ static VOID FspIoqProcessReleaseLock(PIO_CSQ IoCsq, _IRQL_restores_ KIRQL Irql)
static VOID FspIoqProcessCompleteCanceledIrp(PIO_CSQ IoCsq, PIRP Irp)
{
FspIopCompleteIrp(Irp, STATUS_CANCELLED);
FSP_IOQ *Ioq = CONTAINING_RECORD(IoCsq, FSP_IOQ, ProcessIoCsq);
Ioq->CompleteCanceledIrp(Irp);
}
VOID FspIoqInitialize(FSP_IOQ *Ioq)
VOID FspIoqInitialize(FSP_IOQ *Ioq, VOID (*CompleteCanceledIrp)(PIRP Irp))
{
ASSERT(0 != CompleteCanceledIrp);
RtlZeroMemory(Ioq, sizeof *Ioq);
KeInitializeSpinLock(&Ioq->SpinLock);
KeInitializeEvent(&Ioq->PendingIrpEvent, NotificationEvent, FALSE);
@@ -207,6 +211,7 @@ VOID FspIoqInitialize(FSP_IOQ *Ioq)
FspIoqProcessAcquireLock,
FspIoqProcessReleaseLock,
FspIoqProcessCompleteCanceledIrp);
Ioq->CompleteCanceledIrp = CompleteCanceledIrp;
}
VOID FspIoqStop(FSP_IOQ *Ioq)
@@ -219,9 +224,9 @@ VOID FspIoqStop(FSP_IOQ *Ioq)
KeReleaseSpinLock(&Ioq->SpinLock, Irql);
PIRP Irp;
while (0 != (Irp = IoCsqRemoveNextIrp(&Ioq->PendingIoCsq, 0)))
FspIoqPendingCompleteCanceledIrp(&Ioq->PendingIoCsq, Irp);
Ioq->CompleteCanceledIrp(Irp);
while (0 != (Irp = IoCsqRemoveNextIrp(&Ioq->ProcessIoCsq, 0)))
FspIoqProcessCompleteCanceledIrp(&Ioq->ProcessIoCsq, Irp);
Ioq->CompleteCanceledIrp(Irp);
}
BOOLEAN FspIoqStopped(FSP_IOQ *Ioq)
@@ -245,9 +250,9 @@ VOID FspIoqRemoveExpired(FSP_IOQ *Ioq, PLARGE_INTEGER Timeout)
PeekContext.ExpirationTime = 0;
PIRP Irp;
while (0 != (Irp = IoCsqRemoveNextIrp(&Ioq->PendingIoCsq, &PeekContext)))
FspIoqPendingCompleteCanceledIrp(&Ioq->PendingIoCsq, Irp);
Ioq->CompleteCanceledIrp(Irp);
while (0 != (Irp = IoCsqRemoveNextIrp(&Ioq->ProcessIoCsq, &PeekContext)))
FspIoqProcessCompleteCanceledIrp(&Ioq->ProcessIoCsq, Irp);
Ioq->CompleteCanceledIrp(Irp);
}
BOOLEAN FspIoqPostIrp(FSP_IOQ *Ioq, PIRP Irp)

22
src/sys/lockctl.c
View File

@@ -8,13 +8,13 @@
static NTSTATUS FspFsvolLockControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolLockControlComplete;
FSP_DRIVER_DISPATCH FspLockControl;
FSP_IOCMPL_DISPATCH FspLockControlComplete;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFsvolLockControl)
#pragma alloc_text(PAGE, FspFsvolLockControlComplete)
#pragma alloc_text(PAGE, FspLockControl)
#pragma alloc_text(PAGE, FspLockControlComplete)
#endif
static NTSTATUS FspFsvolLockControl(
@@ -25,13 +25,19 @@ static NTSTATUS FspFsvolLockControl(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolLockControlComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
NTSTATUS FspLockControl(
PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_LOCK_CONTROL == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -42,11 +48,3 @@ NTSTATUS FspLockControl(
FSP_LEAVE_MJ("%s", "");
}
VOID FspLockControlComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}

109
src/sys/misc.c
View File

@@ -1,109 +0,0 @@
/**
* @file sys/misc.c
*
* @copyright 2015 Bill Zissimopoulos
*/
#include <sys/driver.h>
NTSTATUS FspCreateGuid(GUID *Guid);
BOOLEAN FspValidRelativeSecurityDescriptor(
PSECURITY_DESCRIPTOR SecurityDescriptor, ULONG SecurityDescriptorLength,
SECURITY_INFORMATION RequiredInformation);
NTSTATUS FspSecuritySubjectContextAccessCheck(
PSECURITY_DESCRIPTOR SecurityDescriptor, ACCESS_MASK DesiredAccess, KPROCESSOR_MODE AccessMode);
VOID FspInitializeWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem,
PWORKER_THREAD_ROUTINE Routine, PVOID Context);
VOID FspQueueWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem, LARGE_INTEGER Timeout);
static KDEFERRED_ROUTINE FspQueueWorkItemWithDelayDPC;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspCreateGuid)
#pragma alloc_text(PAGE, FspValidRelativeSecurityDescriptor)
#pragma alloc_text(PAGE, FspSecuritySubjectContextAccessCheck)
#pragma alloc_text(PAGE, FspInitializeWorkItemWithDelay)
#pragma alloc_text(PAGE, FspQueueWorkItemWithDelay)
#endif
NTSTATUS FspCreateGuid(GUID *Guid)
{
PAGED_CODE();
NTSTATUS Result;
int Retries = 3;
do
{
Result = ExUuidCreate(Guid);
} while (!NT_SUCCESS(Result) && 0 < --Retries);
return Result;
}
BOOLEAN FspValidRelativeSecurityDescriptor(
PSECURITY_DESCRIPTOR SecurityDescriptor, ULONG SecurityDescriptorLength,
SECURITY_INFORMATION RequiredInformation)
{
PAGED_CODE();
BOOLEAN Result;
try
{
Result = RtlValidRelativeSecurityDescriptor(SecurityDescriptor, SecurityDescriptorLength,
RequiredInformation);
}
except (EXCEPTION_EXECUTE_HANDLER)
{
Result = FALSE;
}
return Result;
}
NTSTATUS FspSecuritySubjectContextAccessCheck(
PSECURITY_DESCRIPTOR SecurityDescriptor, ACCESS_MASK DesiredAccess, KPROCESSOR_MODE AccessMode)
{
PAGED_CODE();
NTSTATUS Result = STATUS_ACCESS_DENIED;
SECURITY_SUBJECT_CONTEXT SecuritySubjectContext;
ACCESS_MASK GrantedAccess;
SeCaptureSubjectContext(&SecuritySubjectContext);
if (SeAccessCheck(SecurityDescriptor,
&SecuritySubjectContext, FALSE,
DesiredAccess, 0, 0, IoGetFileObjectGenericMapping(), AccessMode,
&GrantedAccess, &Result))
Result = STATUS_SUCCESS;
SeReleaseSubjectContext(&SecuritySubjectContext);
return Result;
}
VOID FspInitializeWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem,
PWORKER_THREAD_ROUTINE Routine, PVOID Context)
{
PAGED_CODE();
KeInitializeTimer(&WorkItem->Timer);
KeInitializeDpc(&WorkItem->Dpc, FspQueueWorkItemWithDelayDPC, WorkItem);
ExInitializeWorkItem(&WorkItem->WorkQueueItem, Routine, Context);
}
VOID FspQueueWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem, LARGE_INTEGER Timeout)
{
PAGED_CODE();
KeSetTimer(&WorkItem->Timer, Timeout, &WorkItem->Dpc);
}
static VOID FspQueueWorkItemWithDelayDPC(PKDPC Dpc,
PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
{
// !PAGED_CODE();
FSP_WORK_ITEM_WITH_DELAY *WorkItem = DeferredContext;
ExQueueWorkItem(&WorkItem->WorkQueueItem, DelayedWorkQueue);
}

22
src/sys/read.c
View File

@@ -8,13 +8,13 @@
static NTSTATUS FspFsvolRead(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolReadComplete;
FSP_DRIVER_DISPATCH FspRead;
FSP_IOCMPL_DISPATCH FspReadComplete;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFsvolRead)
#pragma alloc_text(PAGE, FspFsvolReadComplete)
#pragma alloc_text(PAGE, FspRead)
#pragma alloc_text(PAGE, FspReadComplete)
#endif
static NTSTATUS FspFsvolRead(
@@ -25,13 +25,19 @@ static NTSTATUS FspFsvolRead(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolReadComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
NTSTATUS FspRead(
PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_READ == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -42,11 +48,3 @@ NTSTATUS FspRead(
FSP_LEAVE_MJ("%s", "");
}
VOID FspReadComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}

86
src/sys/resource.c
View File

@@ -1,86 +0,0 @@
/**
* @file sys/resource.c
*
* @copyright 2015 Bill Zissimopoulos
*/
#include <sys/driver.h>
FAST_IO_ACQUIRE_FILE FspAcquireFileForNtCreateSection;
FAST_IO_RELEASE_FILE FspReleaseFileForNtCreateSection;
FAST_IO_ACQUIRE_FOR_MOD_WRITE FspAcquireForModWrite;
FAST_IO_RELEASE_FOR_MOD_WRITE FspReleaseForModWrite;
FAST_IO_ACQUIRE_FOR_CCFLUSH FspAcquireForCcFlush;
FAST_IO_RELEASE_FOR_CCFLUSH FspReleaseForCcFlush;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspAcquireFileForNtCreateSection)
#pragma alloc_text(PAGE, FspReleaseFileForNtCreateSection)
#pragma alloc_text(PAGE, FspAcquireForModWrite)
#pragma alloc_text(PAGE, FspReleaseForModWrite)
#pragma alloc_text(PAGE, FspAcquireForCcFlush)
#pragma alloc_text(PAGE, FspReleaseForCcFlush)
#endif
VOID FspAcquireFileForNtCreateSection(
PFILE_OBJECT FileObject)
{
FSP_ENTER_VOID(PAGED_CODE());
FSP_LEAVE_VOID("%s", "");
}
VOID FspReleaseFileForNtCreateSection(
PFILE_OBJECT FileObject)
{
FSP_ENTER_VOID(PAGED_CODE());
FSP_LEAVE_VOID("%s", "");
}
NTSTATUS FspAcquireForModWrite(
PFILE_OBJECT FileObject,
PLARGE_INTEGER EndingOffset,
PERESOURCE *ResourceToRelease,
PDEVICE_OBJECT DeviceObject)
{
FSP_ENTER(PAGED_CODE());
Result = STATUS_NOT_IMPLEMENTED;
FSP_LEAVE("%s", "");
}
NTSTATUS FspReleaseForModWrite(
PFILE_OBJECT FileObject,
PERESOURCE ResourceToRelease,
PDEVICE_OBJECT DeviceObject)
{
FSP_ENTER(PAGED_CODE());
Result = STATUS_NOT_IMPLEMENTED;
FSP_LEAVE("%s", "");
}
NTSTATUS FspAcquireForCcFlush(
PFILE_OBJECT FileObject,
PDEVICE_OBJECT DeviceObject)
{
FSP_ENTER(PAGED_CODE());
Result = STATUS_NOT_IMPLEMENTED;
FSP_LEAVE("%s", "");
}
NTSTATUS FspReleaseForCcFlush(
PFILE_OBJECT FileObject,
PDEVICE_OBJECT DeviceObject)
{
FSP_ENTER(PAGED_CODE());
Result = STATUS_NOT_IMPLEMENTED;
FSP_LEAVE("%s", "");
}

44
src/sys/security.c
View File

@@ -8,20 +8,20 @@
static NTSTATUS FspFsvolQuerySecurity(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolQuerySecurityComplete;
static NTSTATUS FspFsvolSetSecurity(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolSetSecurityComplete;
FSP_DRIVER_DISPATCH FspQuerySecurity;
FSP_DRIVER_DISPATCH FspSetSecurity;
FSP_IOCMPL_DISPATCH FspQuerySecurityComplete;
FSP_IOCMPL_DISPATCH FspSetSecurityComplete;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFsvolQuerySecurity)
#pragma alloc_text(PAGE, FspFsvolQuerySecurityComplete)
#pragma alloc_text(PAGE, FspFsvolSetSecurity)
#pragma alloc_text(PAGE, FspFsvolSetSecurityComplete)
#pragma alloc_text(PAGE, FspQuerySecurity)
#pragma alloc_text(PAGE, FspSetSecurity)
#pragma alloc_text(PAGE, FspQuerySecurityComplete)
#pragma alloc_text(PAGE, FspSetSecurityComplete)
#endif
static NTSTATUS FspFsvolQuerySecurity(
@@ -32,6 +32,14 @@ static NTSTATUS FspFsvolQuerySecurity(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolQuerySecurityComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
static NTSTATUS FspFsvolSetSecurity(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
@@ -40,13 +48,19 @@ static NTSTATUS FspFsvolSetSecurity(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolSetSecurityComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
NTSTATUS FspQuerySecurity(
PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_QUERY_SECURITY == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -63,8 +77,6 @@ NTSTATUS FspSetSecurity(
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_SET_SECURITY == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -75,19 +87,3 @@ NTSTATUS FspSetSecurity(
FSP_LEAVE_MJ("%s", "");
}
VOID FspQuerySecurityComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
VOID FspSetSecurityComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}

22
src/sys/shutdown.c
View File

@@ -9,12 +9,12 @@
static NTSTATUS FspFsvolShutdown(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_DRIVER_DISPATCH FspShutdown;
FSP_IOCMPL_DISPATCH FspShutdownComplete;
FSP_IOCMPL_DISPATCH FspFsvolShutdownComplete;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFsvolShutdown)
#pragma alloc_text(PAGE, FspFsvolShutdownComplete)
#pragma alloc_text(PAGE, FspShutdown)
#pragma alloc_text(PAGE, FspShutdownComplete)
#endif
static NTSTATUS FspFsvolShutdown(
@@ -25,13 +25,19 @@ static NTSTATUS FspFsvolShutdown(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolShutdownComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
NTSTATUS FspShutdown(
PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_SHUTDOWN == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -42,11 +48,3 @@ NTSTATUS FspShutdown(
FSP_LEAVE_MJ("%s", "");
}
VOID FspShutdownComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}

61
src/sys/util.c Normal file
View File

@@ -0,0 +1,61 @@
/**
* @file sys/util.c
*
* @copyright 2015 Bill Zissimopoulos
*/
#include <sys/driver.h>
NTSTATUS FspCreateGuid(GUID *Guid);
VOID FspInitializeWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem,
PWORKER_THREAD_ROUTINE Routine, PVOID Context);
VOID FspQueueWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem, LARGE_INTEGER Timeout);
static KDEFERRED_ROUTINE FspQueueWorkItemWithDelayDPC;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspCreateGuid)
#pragma alloc_text(PAGE, FspInitializeWorkItemWithDelay)
#pragma alloc_text(PAGE, FspQueueWorkItemWithDelay)
#endif
NTSTATUS FspCreateGuid(GUID *Guid)
{
PAGED_CODE();
NTSTATUS Result;
int Retries = 3;
do
{
Result = ExUuidCreate(Guid);
} while (!NT_SUCCESS(Result) && 0 < --Retries);
return Result;
}
VOID FspInitializeWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem,
PWORKER_THREAD_ROUTINE Routine, PVOID Context)
{
PAGED_CODE();
KeInitializeTimer(&WorkItem->Timer);
KeInitializeDpc(&WorkItem->Dpc, FspQueueWorkItemWithDelayDPC, WorkItem);
ExInitializeWorkItem(&WorkItem->WorkQueueItem, Routine, Context);
}
VOID FspQueueWorkItemWithDelay(FSP_WORK_ITEM_WITH_DELAY *WorkItem, LARGE_INTEGER Timeout)
{
PAGED_CODE();
KeSetTimer(&WorkItem->Timer, Timeout, &WorkItem->Dpc);
}
static VOID FspQueueWorkItemWithDelayDPC(PKDPC Dpc,
PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
{
// !PAGED_CODE();
FSP_WORK_ITEM_WITH_DELAY *WorkItem = DeferredContext;
ExQueueWorkItem(&WorkItem->WorkQueueItem, DelayedWorkQueue);
}

44
src/sys/volinfo.c
View File

@@ -8,20 +8,20 @@
static NTSTATUS FspFsvolQueryVolumeInformation(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolQueryVolumeInformationComplete;
static NTSTATUS FspFsvolSetVolumeInformation(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolSetVolumeInformationComplete;
FSP_DRIVER_DISPATCH FspQueryVolumeInformation;
FSP_DRIVER_DISPATCH FspSetVolumeInformation;
FSP_IOCMPL_DISPATCH FspQueryVolumeInformationComplete;
FSP_IOCMPL_DISPATCH FspSetVolumeInformationComplete;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFsvolQueryVolumeInformation)
#pragma alloc_text(PAGE, FspFsvolQueryVolumeInformationComplete)
#pragma alloc_text(PAGE, FspFsvolSetVolumeInformation)
#pragma alloc_text(PAGE, FspFsvolSetVolumeInformationComplete)
#pragma alloc_text(PAGE, FspQueryVolumeInformation)
#pragma alloc_text(PAGE, FspSetVolumeInformation)
#pragma alloc_text(PAGE, FspQueryVolumeInformationComplete)
#pragma alloc_text(PAGE, FspSetVolumeInformationComplete)
#endif
static NTSTATUS FspFsvolQueryVolumeInformation(
@@ -32,6 +32,14 @@ static NTSTATUS FspFsvolQueryVolumeInformation(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolQueryVolumeInformationComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
static NTSTATUS FspFsvolSetVolumeInformation(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
@@ -40,13 +48,19 @@ static NTSTATUS FspFsvolSetVolumeInformation(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolSetVolumeInformationComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
NTSTATUS FspQueryVolumeInformation(
PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_QUERY_VOLUME_INFORMATION == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -63,8 +77,6 @@ NTSTATUS FspSetVolumeInformation(
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_SET_VOLUME_INFORMATION == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -75,19 +87,3 @@ NTSTATUS FspSetVolumeInformation(
FSP_LEAVE_MJ("%s", "");
}
VOID FspQueryVolumeInformationComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
VOID FspSetVolumeInformationComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}

22
src/sys/write.c
View File

@@ -8,13 +8,13 @@
static NTSTATUS FspFsvolWrite(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
FSP_IOCMPL_DISPATCH FspFsvolWriteComplete;
FSP_DRIVER_DISPATCH FspWrite;
FSP_IOCMPL_DISPATCH FspWriteComplete;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, FspFsvolWrite)
#pragma alloc_text(PAGE, FspFsvolWriteComplete)
#pragma alloc_text(PAGE, FspWrite)
#pragma alloc_text(PAGE, FspWriteComplete)
#endif
static NTSTATUS FspFsvolWrite(
@@ -25,13 +25,19 @@ static NTSTATUS FspFsvolWrite(
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID FspFsvolWriteComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}
NTSTATUS FspWrite(
PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
FSP_ENTER_MJ(PAGED_CODE());
ASSERT(IRP_MJ_WRITE == IrpSp->MajorFunction);
switch (FspDeviceExtension(DeviceObject)->Kind)
{
case FspFsvolDeviceExtensionKind:
@@ -42,11 +48,3 @@ NTSTATUS FspWrite(
FSP_LEAVE_MJ("%s", "");
}
VOID FspWriteComplete(
PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response)
{
FSP_ENTER_IOC(PAGED_CODE());
FSP_LEAVE_IOC("%s", "");
}