NTSTATUS
DokanCreateGlobalDiskDevice(
__in PDRIVER_OBJECT DriverObject,
__out PDOKAN_GLOBAL* DokanGlobal
)
{
WCHAR deviceNameBuf[] = DOKAN_GLOBAL_DEVICE_NAME;
WCHAR symbolicLinkBuf[] = DOKAN_GLOBAL_SYMBOLIC_LINK_NAME;
NTSTATUS status;
UNICODE_STRING deviceName;
UNICODE_STRING symbolicLinkName;
PDEVICE_OBJECT deviceObject;
PDOKAN_GLOBAL dokanGlobal;
RtlInitUnicodeString(&deviceName, deviceNameBuf);
RtlInitUnicodeString(&symbolicLinkName, symbolicLinkBuf);
status = IoCreateDeviceSecure(
DriverObject, // DriverObject
sizeof(DOKAN_GLOBAL),// DeviceExtensionSize
&deviceName, // DeviceName
FILE_DEVICE_UNKNOWN,// DeviceType
0, // DeviceCharacteristics
FALSE, // Not Exclusive
&sddl, // Default SDDL String
NULL, // Device Class GUID
&deviceObject); // DeviceObject
if (!NT_SUCCESS(status)) {
DDbgPrint(" IoCreateDevice returned 0x%x\n", status);
return status;
}
DDbgPrint("DokanGlobalDevice: %wZ created\n", &deviceName);
ObReferenceObject(deviceObject);
status = IoCreateSymbolicLink(&symbolicLinkName, &deviceName);
if (!NT_SUCCESS(status)) {
DDbgPrint(" IoCreateSymbolicLink returned 0x%x\n", status);
IoDeleteDevice(deviceObject);
return status;
}
DDbgPrint("SymbolicLink: %wZ -> %wZ created\n", &deviceName, &symbolicLinkName);
dokanGlobal = deviceObject->DeviceExtension;
dokanGlobal->DeviceObject = deviceObject;
RtlZeroMemory(dokanGlobal, sizeof(DOKAN_GLOBAL));
DokanInitIrpList(&dokanGlobal->PendingService);
DokanInitIrpList(&dokanGlobal->NotifyService);
dokanGlobal->Identifier.Type = DGL;
dokanGlobal->Identifier.Size = sizeof(DOKAN_GLOBAL);
*DokanGlobal = dokanGlobal;
return STATUS_SUCCESS;
}
NTSTATUS
DriverEntry(
__in PDRIVER_OBJECT DriverObject,
__in PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This routine gets called by the system to initialize the driver.
Arguments:
DriverObject - the system supplied driver object.
RegistryPath - the system supplied registry path for this driver.
Return Value:
NTSTATUS
--*/
{
PDEVICE_OBJECT deviceObject;
NTSTATUS status;
PFAST_IO_DISPATCH fastIoDispatch;
ULONG deviceNumber;
PDOKAN_GLOBAL dokanGlobal;
UNICODE_STRING functionName;
DDbgPrint("==> DriverEntry ver.%x, %s %s\n", DOKAN_VERSION, __DATE__, __TIME__);
dokanGlobal = ExAllocatePool(sizeof(DOKAN_GLOBAL));
if (dokanGlobal == NULL) {
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(dokanGlobal, sizeof(DOKAN_GLOBAL));
DokanInitIrpList(&dokanGlobal->PendingService);
DokanInitIrpList(&dokanGlobal->NotifyService);
for (deviceNumber = 0; deviceNumber < DOKAN_DEVICE_MAX; ++deviceNumber) {
status = DokanCreateDiskDevice(DriverObject, deviceNumber, dokanGlobal);
if (status != STATUS_SUCCESS)
break;
}
//
// Set up dispatch entry points for the driver.
//
DriverObject->DriverUnload = DokanUnload;
DriverObject->MajorFunction[IRP_MJ_CREATE] = DokanDispatchCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = DokanDispatchClose;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = DokanDispatchCleanup;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DokanDispatchDeviceControl;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = DokanDispatchFileSystemControl;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = DokanDispatchDirectoryControl;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = DokanDispatchQueryInformation;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = DokanDispatchSetInformation;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = DokanDispatchQueryVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] = DokanDispatchSetVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_READ] = DokanDispatchRead;
DriverObject->MajorFunction[IRP_MJ_WRITE] = DokanDispatchWrite;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = DokanDispatchFlush;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = DokanDispatchShutdown;
DriverObject->MajorFunction[IRP_MJ_PNP] = DokanDispatchPnp;
DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = DokanDispatchLock;
//fastIoDispatch = ExAllocatePool(sizeof(FAST_IO_DISPATCH));
// TODO: check fastIoDispatch
//RtlZeroMemory(fastIoDispatch, sizeof(FAST_IO_DISPATCH));
//fastIoDispatch->SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
//fastIoDispatch->FastIoCheckIfPossible = DokanFastIoCheckIfPossible;
//fastIoDispatch->FastIoRead = DokanFastIoRead;
//fastIoDispatch->AcquireFileForNtCreateSection = DokanAcquireForCreateSection;
//fastIoDispatch->ReleaseFileForNtCreateSection = DokanReleaseForCreateSection;
//DriverObject->FastIoDispatch = fastIoDispatch;
#if _WIN32_WINNT < 0x0501
RtlInitUnicodeString(&functionName, L"FsRtlTeardownPerStreamContexts");
DokanFsRtlTeardownPerStreamContexts = MmGetSystemRoutineAddress(&functionName);
#endif
DDbgPrint("<== DriverEntry\n");
return( status );
}
NTSTATUS
DokanCreateDiskDevice(__in PDRIVER_OBJECT DriverObject, __in ULONG MountId,
__in PWCHAR MountPoint, __in PWCHAR UNCName,
__in PWCHAR BaseGuid, __in PDOKAN_GLOBAL DokanGlobal,
__in DEVICE_TYPE DeviceType,
__in ULONG DeviceCharacteristics,
__in BOOLEAN UseMountManager, __out PDokanDCB *Dcb) {
WCHAR diskDeviceNameBuf[MAXIMUM_FILENAME_LENGTH];
WCHAR symbolicLinkNameBuf[MAXIMUM_FILENAME_LENGTH];
WCHAR mountPointBuf[MAXIMUM_FILENAME_LENGTH];
PDEVICE_OBJECT diskDeviceObject;
PDEVICE_OBJECT volDeviceObject;
PDokanDCB dcb;
PDokanVCB vcb;
UNICODE_STRING diskDeviceName;
NTSTATUS status;
BOOLEAN isNetworkFileSystem = (DeviceType == FILE_DEVICE_NETWORK_FILE_SYSTEM);
DOKAN_CONTROL dokanControl;
// make DeviceName and SymboliLink
if (isNetworkFileSystem) {
#ifdef DOKAN_NET_PROVIDER
RtlStringCchCopyW(diskDeviceNameBuf, MAXIMUM_FILENAME_LENGTH,
DOKAN_NET_DEVICE_NAME);
RtlStringCchCopyW(symbolicLinkNameBuf, MAXIMUM_FILENAME_LENGTH,
DOKAN_NET_SYMBOLIC_LINK_NAME);
#else
RtlStringCchCopyW(diskDeviceNameBuf, MAXIMUM_FILENAME_LENGTH,
DOKAN_NET_DEVICE_NAME);
RtlStringCchCatW(diskDeviceNameBuf, MAXIMUM_FILENAME_LENGTH, BaseGuid);
RtlStringCchCopyW(symbolicLinkNameBuf, MAXIMUM_FILENAME_LENGTH,
DOKAN_NET_SYMBOLIC_LINK_NAME);
RtlStringCchCatW(symbolicLinkNameBuf, MAXIMUM_FILENAME_LENGTH, BaseGuid);
#endif
} else {
RtlStringCchCopyW(diskDeviceNameBuf, MAXIMUM_FILENAME_LENGTH,
DOKAN_DISK_DEVICE_NAME);
RtlStringCchCatW(diskDeviceNameBuf, MAXIMUM_FILENAME_LENGTH, BaseGuid);
RtlStringCchCopyW(symbolicLinkNameBuf, MAXIMUM_FILENAME_LENGTH,
DOKAN_SYMBOLIC_LINK_NAME);
RtlStringCchCatW(symbolicLinkNameBuf, MAXIMUM_FILENAME_LENGTH, BaseGuid);
}
RtlInitUnicodeString(&diskDeviceName, diskDeviceNameBuf);
//
// Create DeviceObject for the Disk Device
//
if (!isNetworkFileSystem) {
status =
IoCreateDeviceSecure(DriverObject, // DriverObject
sizeof(DokanDCB), // DeviceExtensionSize
&diskDeviceName, // DeviceName
FILE_DEVICE_DISK, // DeviceType
DeviceCharacteristics, // DeviceCharacteristics
FALSE, // Not Exclusive
&sddl, // Default SDDL String
NULL, // Device Class GUID
&diskDeviceObject); // DeviceObject
} else {
status = IoCreateDevice(DriverObject, // DriverObject
sizeof(DokanDCB), // DeviceExtensionSize
NULL, // DeviceName
FILE_DEVICE_UNKNOWN, // DeviceType
DeviceCharacteristics, // DeviceCharacteristics
FALSE, // Not Exclusive
&diskDeviceObject); // DeviceObject
}
if (!NT_SUCCESS(status)) {
DDbgPrint(" %s failed: 0x%x\n",
isNetworkFileSystem ? "IoCreateDevice(FILE_DEVICE_UNKNOWN)"
: "IoCreateDeviceSecure(FILE_DEVICE_DISK)",
status);
return status;
}
//
// Initialize the device extension.
//
dcb = diskDeviceObject->DeviceExtension;
*Dcb = dcb;
dcb->DeviceObject = diskDeviceObject;
dcb->Global = DokanGlobal;
dcb->Identifier.Type = DCB;
dcb->Identifier.Size = sizeof(DokanDCB);
dcb->MountId = MountId;
dcb->DeviceType = FILE_DEVICE_DISK;
dcb->DeviceCharacteristics = DeviceCharacteristics;
KeInitializeEvent(&dcb->KillEvent, NotificationEvent, FALSE);
//
// Establish user-buffer access method.
//
diskDeviceObject->Flags |= DO_DIRECT_IO;
// initialize Event and Event queue
DokanInitIrpList(&dcb->PendingIrp);
DokanInitIrpList(&dcb->PendingEvent);
DokanInitIrpList(&dcb->NotifyEvent);
KeInitializeEvent(&dcb->ReleaseEvent, NotificationEvent, FALSE);
// "0" means not mounted
dcb->Mounted = 0;
ExInitializeResourceLite(&dcb->Resource);
dcb->CacheManagerNoOpCallbacks.AcquireForLazyWrite = &DokanNoOpAcquire;
dcb->CacheManagerNoOpCallbacks.ReleaseFromLazyWrite = &DokanNoOpRelease;
dcb->CacheManagerNoOpCallbacks.AcquireForReadAhead = &DokanNoOpAcquire;
dcb->CacheManagerNoOpCallbacks.ReleaseFromReadAhead = &DokanNoOpRelease;
dcb->UseMountManager = UseMountManager;
if (wcscmp(MountPoint, L"") != 0) {
RtlStringCchCopyW(mountPointBuf, MAXIMUM_FILENAME_LENGTH,
L"\\DosDevices\\");
if (wcslen(MountPoint) < 4) {
mountPointBuf[12] = towupper(MountPoint[0]);
mountPointBuf[13] = L':';
mountPointBuf[14] = L'\0';
if (isNetworkFileSystem) {
dcb->UseMountManager = FALSE;
}
} else {
dcb->UseMountManager = FALSE;
RtlStringCchCatW(mountPointBuf, MAXIMUM_FILENAME_LENGTH, MountPoint);
}
} else {
RtlStringCchCopyW(mountPointBuf, MAXIMUM_FILENAME_LENGTH, L"");
}
dcb->DiskDeviceName = DokanAllocateUnicodeString(diskDeviceNameBuf);
dcb->SymbolicLinkName = DokanAllocateUnicodeString(symbolicLinkNameBuf);
dcb->MountPoint = DokanAllocateUnicodeString(mountPointBuf);
if (UNCName != NULL) {
dcb->UNCName = DokanAllocateUnicodeString(UNCName);
}
if (dcb->DiskDeviceName == NULL || dcb->SymbolicLinkName == NULL ||
dcb->MountPoint == NULL || (dcb->UNCName == NULL && UNCName != NULL)) {
DDbgPrint(" Failed to allocate memory for device naming");
FreeDcbNames(dcb);
ExDeleteResourceLite(&dcb->Resource);
IoDeleteDevice(diskDeviceObject);
return STATUS_INSUFFICIENT_RESOURCES;
}
DDbgPrint("DiskDeviceName: %wZ - SymbolicLinkName: %wZ - MountPoint: %wZ\n",
dcb->DiskDeviceName, dcb->SymbolicLinkName, dcb->MountPoint);
DDbgPrint(" IoCreateDevice DeviceType: %d\n", DeviceType);
// Directly create volume device and init vcb here because it has strong
// dependency with fs/disk
// Otherwise we would have done this work when mounting the volume
if (!isNetworkFileSystem) {
status = IoCreateDevice(DriverObject, // DriverObject
sizeof(DokanVCB), // DeviceExtensionSize
NULL, // DeviceName
DeviceType, // DeviceType
DeviceCharacteristics, // DeviceCharacteristics
FALSE, // Not Exclusive
&volDeviceObject); // DeviceObject
} else {
status =
IoCreateDeviceSecure(DriverObject, // DriverObject
sizeof(DokanVCB), // DeviceExtensionSize
&diskDeviceName, // DeviceName
DeviceType, // DeviceType
DeviceCharacteristics, // DeviceCharacteristics
FALSE, // Not Exclusive
&sddl, // Default SDDL String
NULL, // Device Class GUID
&volDeviceObject); // DeviceObject
}
if (!NT_SUCCESS(status)) {
DDbgPrint(" IoCreateDevice failed: 0x%x\n", status);
ExDeleteResourceLite(&dcb->Resource);
IoDeleteDevice(diskDeviceObject);
FreeDcbNames(dcb);
return status;
}
vcb = volDeviceObject->DeviceExtension;
vcb->Identifier.Type = VCB;
vcb->Identifier.Size = sizeof(DokanVCB);
vcb->DeviceObject = volDeviceObject;
vcb->Dcb = dcb;
dcb->Vcb = vcb;
InitializeListHead(&vcb->NextFCB);
InitializeListHead(&vcb->DirNotifyList);
FsRtlNotifyInitializeSync(&vcb->NotifySync);
ExInitializeFastMutex(&vcb->AdvancedFCBHeaderMutex);
#if _WIN32_WINNT >= 0x0501
FsRtlSetupAdvancedHeader(&vcb->VolumeFileHeader,
&vcb->AdvancedFCBHeaderMutex);
#else
if (DokanFsRtlTeardownPerStreamContexts) {
FsRtlSetupAdvancedHeader(&vcb->VolumeFileHeader,
&vcb->AdvancedFCBHeaderMutex);
}
#endif
//
// Create a symbolic link for userapp to interact with the driver.
//
status = IoCreateSymbolicLink(dcb->SymbolicLinkName, dcb->DiskDeviceName);
if (!NT_SUCCESS(status)) {
ExDeleteResourceLite(&dcb->Resource);
IoDeleteDevice(diskDeviceObject);
FreeDcbNames(dcb);
DDbgPrint(" IoCreateSymbolicLink returned 0x%x\n", status);
return status;
}
DDbgPrint("SymbolicLink: %wZ -> %wZ created\n", dcb->SymbolicLinkName,
dcb->DiskDeviceName);
//
// Establish user-buffer access method.
//
volDeviceObject->Flags |= DO_DIRECT_IO;
DokanInitVpb(diskDeviceObject->Vpb, diskDeviceObject, volDeviceObject);
// Mark devices as initialized
diskDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
volDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
ObReferenceObject(volDeviceObject);
ObReferenceObject(diskDeviceObject);
// DokanRegisterMountedDeviceInterface(diskDeviceObject, dcb);
// Save to the global mounted list
RtlZeroMemory(&dokanControl, sizeof(dokanControl));
RtlStringCchCopyW(dokanControl.DeviceName,
sizeof(dokanControl.DeviceName) / sizeof(WCHAR),
diskDeviceNameBuf);
RtlStringCchCopyW(dokanControl.MountPoint,
sizeof(dokanControl.MountPoint) / sizeof(WCHAR),
mountPointBuf);
dokanControl.Type = DeviceType;
dokanControl.DeviceObject = volDeviceObject;
InsertMountEntry(DokanGlobal, &dokanControl);
dcb->Mounted = 1;
if (dcb->UseMountManager) {
status = DokanSendVolumeArrivalNotification(dcb->DiskDeviceName);
if (!NT_SUCCESS(status)) {
DDbgPrint(" DokanSendVolumeArrivalNotification failed: 0x%x\n", status);
if (diskDeviceObject->Vpb) {
diskDeviceObject->Vpb->DeviceObject = NULL;
diskDeviceObject->Vpb->RealDevice = NULL;
diskDeviceObject->Vpb->Flags = 0;
}
ExDeleteResourceLite(&dcb->Resource);
IoDeleteDevice(diskDeviceObject);
FreeDcbNames(dcb);
return status;
}
}
DokanCreateMountPoint(dcb);
if (isNetworkFileSystem) {
// Run FsRtlRegisterUncProvider in System thread.
HANDLE handle;
PKTHREAD thread;
OBJECT_ATTRIBUTES objectAttribs;
InitializeObjectAttributes(&objectAttribs, NULL, OBJ_KERNEL_HANDLE, NULL,
NULL);
status = PsCreateSystemThread(
&handle, THREAD_ALL_ACCESS, &objectAttribs, NULL, NULL,
(PKSTART_ROUTINE)DokanRegisterUncProvider, dcb);
if (!NT_SUCCESS(status)) {
DDbgPrint("PsCreateSystemThread failed: 0x%X\n", status);
} else {
ObReferenceObjectByHandle(handle, THREAD_ALL_ACCESS, NULL, KernelMode,
&thread, NULL);
ZwClose(handle);
KeWaitForSingleObject(thread, Executive, KernelMode, FALSE, NULL);
ObDereferenceObject(thread);
}
}
// DokanRegisterDeviceInterface(DriverObject, diskDeviceObject, dcb);
return STATUS_SUCCESS;
}
NTSTATUS
DokanCreateGlobalDiskDevice(__in PDRIVER_OBJECT DriverObject,
__out PDOKAN_GLOBAL *DokanGlobal) {
WCHAR deviceNameBuf[] = DOKAN_GLOBAL_DEVICE_NAME;
WCHAR symbolicLinkBuf[] = DOKAN_GLOBAL_SYMBOLIC_LINK_NAME;
WCHAR fsDiskDeviceNameBuf[] = DOKAN_GLOBAL_FS_DISK_DEVICE_NAME;
WCHAR fsCdDeviceNameBuf[] = DOKAN_GLOBAL_FS_CD_DEVICE_NAME;
NTSTATUS status;
UNICODE_STRING deviceName;
UNICODE_STRING symbolicLinkName;
UNICODE_STRING fsDiskDeviceName;
UNICODE_STRING fsCdDeviceName;
PDEVICE_OBJECT deviceObject;
PDEVICE_OBJECT fsDiskDeviceObject;
PDEVICE_OBJECT fsCdDeviceObject;
PDOKAN_GLOBAL dokanGlobal;
RtlInitUnicodeString(&deviceName, deviceNameBuf);
RtlInitUnicodeString(&symbolicLinkName, symbolicLinkBuf);
RtlInitUnicodeString(&fsDiskDeviceName, fsDiskDeviceNameBuf);
RtlInitUnicodeString(&fsCdDeviceName, fsCdDeviceNameBuf);
status = IoCreateDeviceSecure(DriverObject, // DriverObject
sizeof(DOKAN_GLOBAL), // DeviceExtensionSize
&deviceName, // DeviceName
FILE_DEVICE_UNKNOWN, // DeviceType
0, // DeviceCharacteristics
FALSE, // Not Exclusive
&sddl, // Default SDDL String
NULL, // Device Class GUID
&deviceObject); // DeviceObject
if (!NT_SUCCESS(status)) {
DDbgPrint(" IoCreateDevice returned 0x%x\n", status);
return status;
}
DDbgPrint("DokanGlobalDevice: %wZ created\n", &deviceName);
// Create supported file system device types and register them
status = IoCreateDeviceSecure(DriverObject, // DriverObject
0, // DeviceExtensionSize
&fsDiskDeviceName, // DeviceName
FILE_DEVICE_DISK_FILE_SYSTEM, // DeviceType
0, // DeviceCharacteristics
FALSE, // Not Exclusive
&sddl, // Default SDDL String
NULL, // Device Class GUID
&fsDiskDeviceObject); // DeviceObject
if (!NT_SUCCESS(status)) {
DDbgPrint(" IoCreateDevice Disk FileSystem failed: 0x%x\n", status);
IoDeleteDevice(deviceObject);
return status;
}
DDbgPrint("DokanDiskFileSystemDevice: %wZ created\n", &fsDiskDeviceName);
status = IoCreateDeviceSecure(DriverObject, // DriverObject
0, // DeviceExtensionSize
&fsCdDeviceName, // DeviceName
FILE_DEVICE_CD_ROM_FILE_SYSTEM, // DeviceType
0, // DeviceCharacteristics
FALSE, // Not Exclusive
&sddl, // Default SDDL String
NULL, // Device Class GUID
&fsCdDeviceObject); // DeviceObject
if (!NT_SUCCESS(status)) {
DDbgPrint(" IoCreateDevice Cd FileSystem failed: 0x%x\n", status);
IoDeleteDevice(fsDiskDeviceObject);
IoDeleteDevice(deviceObject);
return status;
}
DDbgPrint("DokanCdFileSystemDevice: %wZ created\n", &fsCdDeviceName);
ObReferenceObject(deviceObject);
status = IoCreateSymbolicLink(&symbolicLinkName, &deviceName);
if (!NT_SUCCESS(status)) {
DDbgPrint(" IoCreateSymbolicLink returned 0x%x\n", status);
IoDeleteDevice(deviceObject);
return status;
}
DDbgPrint("SymbolicLink: %wZ -> %wZ created\n", &deviceName,
&symbolicLinkName);
dokanGlobal = deviceObject->DeviceExtension;
dokanGlobal->DeviceObject = deviceObject;
dokanGlobal->FsDiskDeviceObject = fsDiskDeviceObject;
dokanGlobal->FsCdDeviceObject = fsCdDeviceObject;
RtlZeroMemory(dokanGlobal, sizeof(DOKAN_GLOBAL));
DokanInitIrpList(&dokanGlobal->PendingService);
DokanInitIrpList(&dokanGlobal->NotifyService);
InitializeListHead(&dokanGlobal->MountPointList);
dokanGlobal->Identifier.Type = DGL;
dokanGlobal->Identifier.Size = sizeof(DOKAN_GLOBAL);
//
// Establish user-buffer access method.
//
fsDiskDeviceObject->Flags |= DO_DIRECT_IO;
fsDiskDeviceObject->Flags |= DO_LOW_PRIORITY_FILESYSTEM;
fsCdDeviceObject->Flags |= DO_DIRECT_IO;
fsCdDeviceObject->Flags |= DO_LOW_PRIORITY_FILESYSTEM;
fsDiskDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
fsCdDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
// Register file systems
IoRegisterFileSystem(fsDiskDeviceObject);
IoRegisterFileSystem(fsCdDeviceObject);
ObReferenceObject(fsDiskDeviceObject);
ObReferenceObject(fsCdDeviceObject);
*DokanGlobal = dokanGlobal;
return STATUS_SUCCESS;
}
NTSTATUS
DokanCreateDiskDevice(
__in PDRIVER_OBJECT DriverObject,
__in ULONG MountId,
__in PWCHAR BaseGuid,
__in PDOKAN_GLOBAL DokanGlobal,
__in DEVICE_TYPE DeviceType,
__in ULONG DeviceCharacteristics,
__out PDokanDCB* Dcb
)
{
WCHAR diskDeviceNameBuf[MAXIMUM_FILENAME_LENGTH];
WCHAR fsDeviceNameBuf[MAXIMUM_FILENAME_LENGTH];
WCHAR symbolicLinkNameBuf[MAXIMUM_FILENAME_LENGTH];
PDEVICE_OBJECT diskDeviceObject;
PDEVICE_OBJECT fsDeviceObject;
PDokanDCB dcb;
PDokanVCB vcb;
UNICODE_STRING diskDeviceName;
NTSTATUS status;
BOOLEAN isNetworkFileSystem = (DeviceType == FILE_DEVICE_NETWORK_FILE_SYSTEM);
// make DeviceName and SymboliLink
if (isNetworkFileSystem) {
#ifdef DOKAN_NET_PROVIDER
RtlStringCchCopyW(diskDeviceNameBuf, MAXIMUM_FILENAME_LENGTH, DOKAN_NET_DEVICE_NAME);
RtlStringCchCopyW(fsDeviceNameBuf, MAXIMUM_FILENAME_LENGTH, DOKAN_NET_DEVICE_NAME);
RtlStringCchCopyW(symbolicLinkNameBuf, MAXIMUM_FILENAME_LENGTH, DOKAN_NET_SYMBOLIC_LINK_NAME);
#else
RtlStringCchCopyW(diskDeviceNameBuf, MAXIMUM_FILENAME_LENGTH, DOKAN_NET_DEVICE_NAME);
RtlStringCchCatW(diskDeviceNameBuf, MAXIMUM_FILENAME_LENGTH, BaseGuid);
RtlStringCchCopyW(fsDeviceNameBuf, MAXIMUM_FILENAME_LENGTH, DOKAN_NET_DEVICE_NAME);
RtlStringCchCatW(fsDeviceNameBuf, MAXIMUM_FILENAME_LENGTH, BaseGuid);
RtlStringCchCopyW(symbolicLinkNameBuf, MAXIMUM_FILENAME_LENGTH, DOKAN_NET_SYMBOLIC_LINK_NAME);
RtlStringCchCatW(symbolicLinkNameBuf, MAXIMUM_FILENAME_LENGTH, BaseGuid);
#endif
} else {
RtlStringCchCopyW(diskDeviceNameBuf, MAXIMUM_FILENAME_LENGTH, DOKAN_DISK_DEVICE_NAME);
RtlStringCchCatW(diskDeviceNameBuf, MAXIMUM_FILENAME_LENGTH, BaseGuid);
RtlStringCchCopyW(fsDeviceNameBuf, MAXIMUM_FILENAME_LENGTH, DOKAN_FS_DEVICE_NAME);
RtlStringCchCatW(fsDeviceNameBuf, MAXIMUM_FILENAME_LENGTH, BaseGuid);
RtlStringCchCopyW(symbolicLinkNameBuf, MAXIMUM_FILENAME_LENGTH, DOKAN_SYMBOLIC_LINK_NAME);
RtlStringCchCatW(symbolicLinkNameBuf, MAXIMUM_FILENAME_LENGTH, BaseGuid);
}
RtlInitUnicodeString(&diskDeviceName, diskDeviceNameBuf);
//
// make a DeviceObject for Disk Device
//
if (!isNetworkFileSystem) {
status = IoCreateDeviceSecure(
DriverObject, // DriverObject
sizeof(DokanDCB), // DeviceExtensionSize
&diskDeviceName, // DeviceName
FILE_DEVICE_DISK, // DeviceType
DeviceCharacteristics, // DeviceCharacteristics
FALSE, // Not Exclusive
&sddl, // Default SDDL String
NULL, // Device Class GUID
&diskDeviceObject); // DeviceObject
} else {
status = IoCreateDevice(
DriverObject, // DriverObject
sizeof(DokanDCB), // DeviceExtensionSize
NULL, // DeviceName
FILE_DEVICE_UNKNOWN, // DeviceType
DeviceCharacteristics, // DeviceCharacteristics
FALSE, // Not Exclusive
&diskDeviceObject); // DeviceObject
}
if (!NT_SUCCESS(status)) {
DDbgPrint(" IoCreateDevice (DISK_DEVICE) failed: 0x%x\n", status);
return status;
}
DDbgPrint("DokanDiskDevice: %wZ created\n", &diskDeviceName);
//
// Initialize the device extension.
//
dcb = diskDeviceObject->DeviceExtension;
*Dcb = dcb;
dcb->DeviceObject = diskDeviceObject;
dcb->Global = DokanGlobal;
dcb->Identifier.Type = DCB;
dcb->Identifier.Size = sizeof(DokanDCB);
dcb->MountId = MountId;
dcb->DeviceType = FILE_DEVICE_DISK;
dcb->DeviceCharacteristics = DeviceCharacteristics;
KeInitializeEvent(&dcb->KillEvent, NotificationEvent, FALSE);
//
// Establish user-buffer access method.
//
diskDeviceObject->Flags |= DO_DIRECT_IO;
// initialize Event and Event queue
DokanInitIrpList(&dcb->PendingIrp);
DokanInitIrpList(&dcb->PendingEvent);
DokanInitIrpList(&dcb->NotifyEvent);
KeInitializeEvent(&dcb->ReleaseEvent, NotificationEvent, FALSE);
// "0" means not mounted
dcb->Mounted = 0;
ExInitializeResourceLite(&dcb->Resource);
dcb->CacheManagerNoOpCallbacks.AcquireForLazyWrite = &DokanNoOpAcquire;
dcb->CacheManagerNoOpCallbacks.ReleaseFromLazyWrite = &DokanNoOpRelease;
dcb->CacheManagerNoOpCallbacks.AcquireForReadAhead = &DokanNoOpAcquire;
dcb->CacheManagerNoOpCallbacks.ReleaseFromReadAhead = &DokanNoOpRelease;
dcb->SymbolicLinkName = AllocateUnicodeString(symbolicLinkNameBuf);
dcb->DiskDeviceName = AllocateUnicodeString(diskDeviceNameBuf);
dcb->FileSystemDeviceName = AllocateUnicodeString(fsDeviceNameBuf);
status = IoCreateDeviceSecure(
DriverObject, // DriverObject
sizeof(DokanVCB), // DeviceExtensionSize
dcb->FileSystemDeviceName, // DeviceName
DeviceType, // DeviceType
DeviceCharacteristics, // DeviceCharacteristics
FALSE, // Not Exclusive
&sddl, // Default SDDL String
NULL, // Device Class GUID
&fsDeviceObject); // DeviceObject
if (!NT_SUCCESS(status)) {
DDbgPrint(" IoCreateDevice (FILE_SYSTEM_DEVICE) failed: 0x%x\n", status);
IoDeleteDevice(diskDeviceObject);
return status;
}
DDbgPrint("DokanFileSystemDevice: %wZ created\n", dcb->FileSystemDeviceName);
vcb = fsDeviceObject->DeviceExtension;
vcb->Identifier.Type = VCB;
vcb->Identifier.Size = sizeof(DokanVCB);
vcb->DeviceObject = fsDeviceObject;
vcb->Dcb = dcb;
dcb->Vcb = vcb;
InitializeListHead(&vcb->NextFCB);
InitializeListHead(&vcb->DirNotifyList);
FsRtlNotifyInitializeSync(&vcb->NotifySync);
ExInitializeFastMutex(&vcb->AdvancedFCBHeaderMutex);
#if _WIN32_WINNT >= 0x0501
FsRtlSetupAdvancedHeader(&vcb->VolumeFileHeader, &vcb->AdvancedFCBHeaderMutex);
#else
if (DokanFsRtlTeardownPerStreamContexts) {
FsRtlSetupAdvancedHeader(&vcb->VolumeFileHeader, &vcb->AdvancedFCBHeaderMutex);
}
#endif
//
// Establish user-buffer access method.
//
fsDeviceObject->Flags |= DO_DIRECT_IO;
if (diskDeviceObject->Vpb) {
// NOTE: This can be done by IoRegisterFileSystem + IRP_MN_MOUNT_VOLUME,
// however that causes BSOD inside filter manager on Vista x86 after mount
// (mouse hover on file).
// Probably FS_FILTER_CALLBACKS.PreAcquireForSectionSynchronization is
// not correctly called in that case.
diskDeviceObject->Vpb->DeviceObject = fsDeviceObject;
diskDeviceObject->Vpb->RealDevice = fsDeviceObject;
diskDeviceObject->Vpb->Flags |= VPB_MOUNTED;
diskDeviceObject->Vpb->VolumeLabelLength = (USHORT)wcslen(VOLUME_LABEL) * sizeof(WCHAR);
RtlStringCchCopyW(diskDeviceObject->Vpb->VolumeLabel,
sizeof(diskDeviceObject->Vpb->VolumeLabel) / sizeof(WCHAR),
VOLUME_LABEL);
diskDeviceObject->Vpb->SerialNumber = 0x19831116;
}
ObReferenceObject(fsDeviceObject);
ObReferenceObject(diskDeviceObject);
//
// Create a symbolic link for userapp to interact with the driver.
//
status = IoCreateSymbolicLink(dcb->SymbolicLinkName, dcb->DiskDeviceName);
if (!NT_SUCCESS(status)) {
if (diskDeviceObject->Vpb) {
diskDeviceObject->Vpb->DeviceObject = NULL;
diskDeviceObject->Vpb->RealDevice = NULL;
diskDeviceObject->Vpb->Flags = 0;
}
IoDeleteDevice(diskDeviceObject);
IoDeleteDevice(fsDeviceObject);
DDbgPrint(" IoCreateSymbolicLink returned 0x%x\n", status);
return status;
}
DDbgPrint("SymbolicLink: %wZ -> %wZ created\n", dcb->SymbolicLinkName, dcb->DiskDeviceName);
// Mark devices as initialized
diskDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
fsDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
//IoRegisterFileSystem(fsDeviceObject);
if (isNetworkFileSystem) {
// Run FsRtlRegisterUncProvider in System thread.
HANDLE handle;
PKTHREAD thread;
OBJECT_ATTRIBUTES objectAttribs;
InitializeObjectAttributes(
&objectAttribs, NULL, OBJ_KERNEL_HANDLE, NULL, NULL);
status = PsCreateSystemThread(&handle, THREAD_ALL_ACCESS,
&objectAttribs, NULL, NULL, (PKSTART_ROUTINE)DokanRegisterUncProvider, dcb);
if (!NT_SUCCESS(status)) {
DDbgPrint("PsCreateSystemThread failed: 0x%X\n", status);
} else {
ObReferenceObjectByHandle(handle, THREAD_ALL_ACCESS, NULL,
KernelMode, &thread, NULL);
ZwClose(handle);
KeWaitForSingleObject(thread, Executive, KernelMode, FALSE, NULL);
ObDereferenceObject(thread);
}
}
//DokanRegisterMountedDeviceInterface(diskDeviceObject, dcb);
dcb->Mounted = 1;
//DokanSendVolumeArrivalNotification(&deviceName);
//DokanRegisterDeviceInterface(DriverObject, diskDeviceObject, dcb);
return STATUS_SUCCESS;
}
