reactos/drivers/filesystems/fs_rec/fs_rec.c

463 lines
14 KiB
C

/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS File System Recognizer
* FILE: drivers/filesystems/fs_rec/fs_rec.c
* PURPOSE: Main Driver Entrypoint and FS Registration
* PROGRAMMER: Alex Ionescu (alex.ionescu@reactos.org)
* Eric Kohl
*/
/* INCLUDES *****************************************************************/
#include "fs_rec.h"
#define NDEBUG
#include <debug.h>
PKEVENT FsRecLoadSync;
/* FUNCTIONS ****************************************************************/
NTSTATUS
NTAPI
FsRecLoadFileSystem(IN PDEVICE_OBJECT DeviceObject,
IN PWCHAR DriverServiceName)
{
UNICODE_STRING DriverName;
PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
NTSTATUS Status = STATUS_IMAGE_ALREADY_LOADED;
PAGED_CODE();
/* Make sure we haven't already been called */
if (DeviceExtension->State != Loaded)
{
/* Acquire the load lock */
KeWaitForSingleObject(FsRecLoadSync,
Executive,
KernelMode,
FALSE,
NULL);
KeEnterCriticalRegion();
/* Make sure we're active */
if (DeviceExtension->State == Pending)
{
/* Load the FS driver */
RtlInitUnicodeString(&DriverName, DriverServiceName);
Status = ZwLoadDriver(&DriverName);
/* Loop all the linked recognizer objects */
while (DeviceExtension->State != Unloading)
{
/* Set them to the unload state */
DeviceExtension->State = Unloading;
/* Go to the next one */
DeviceObject = DeviceExtension->Alternate;
DeviceExtension = DeviceObject->DeviceExtension;
}
}
/* Make sure that we haven't already loaded the FS */
if (DeviceExtension->State != Loaded)
{
/* Unregister us, and set us as loaded */
IoUnregisterFileSystem(DeviceObject);
DeviceExtension->State = Loaded;
}
/* Release the lock */
KeSetEvent(FsRecLoadSync, 0, FALSE);
KeLeaveCriticalRegion();
}
/* Return */
return Status;
}
DRIVER_DISPATCH FsRecCreate;
NTSTATUS
NTAPI
FsRecCreate(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
NTSTATUS Status;
PAGED_CODE();
UNREFERENCED_PARAMETER(DeviceObject);
/* Make sure we have a file name */
if (IoStack->FileObject->FileName.Length)
{
/* Fail the request */
Status = STATUS_OBJECT_PATH_NOT_FOUND;
}
else
{
/* Let it through */
Status = STATUS_SUCCESS;
}
/* Complete the IRP */
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = FILE_OPENED;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
DRIVER_DISPATCH FsRecClose;
NTSTATUS
NTAPI
FsRecClose(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
PAGED_CODE();
UNREFERENCED_PARAMETER(DeviceObject);
/* Just complete the IRP and return success */
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
DRIVER_DISPATCH FsRecFsControl;
NTSTATUS
NTAPI
FsRecFsControl(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
NTSTATUS Status;
PAGED_CODE();
/* Check the file system type */
switch (DeviceExtension->FsType)
{
case FS_TYPE_VFAT:
/* Send FAT command */
Status = FsRecVfatFsControl(DeviceObject, Irp);
break;
case FS_TYPE_NTFS:
/* Send NTFS command */
Status = FsRecNtfsFsControl(DeviceObject, Irp);
break;
case FS_TYPE_CDFS:
/* Send CDFS command */
Status = FsRecCdfsFsControl(DeviceObject, Irp);
break;
case FS_TYPE_UDFS:
/* Send UDFS command */
Status = FsRecUdfsFsControl(DeviceObject, Irp);
break;
case FS_TYPE_EXT2:
/* Send EXT2 command */
Status = FsRecExt2FsControl(DeviceObject, Irp);
break;
case FS_TYPE_BTRFS:
/* Send BTRFS command */
Status = FsRecBtrfsFsControl(DeviceObject, Irp);
break;
case FS_TYPE_REISERFS:
/* Send REISERFS command */
Status = FsRecReiserfsFsControl(DeviceObject, Irp);
break;
case FS_TYPE_FFS:
/* Send FFS command */
Status = FsRecFfsFsControl(DeviceObject, Irp);
break;
default:
/* Unrecognized FS */
Status = STATUS_INVALID_DEVICE_REQUEST;
}
/* Complete the IRP */
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
DRIVER_UNLOAD FsRecUnload;
VOID
NTAPI
FsRecUnload(IN PDRIVER_OBJECT DriverObject)
{
PAGED_CODE();
/* Loop all driver device objects */
while (DriverObject->DeviceObject)
{
/* Delete this device */
IoDeleteDevice(DriverObject->DeviceObject);
}
/* Free the lock */
ExFreePool(FsRecLoadSync);
}
NTSTATUS
NTAPI
FsRecRegisterFs(IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT ParentObject OPTIONAL,
OUT PDEVICE_OBJECT *NewDeviceObject OPTIONAL,
IN PCWSTR FsName,
IN PCWSTR RecognizerName,
IN ULONG FsType,
IN DEVICE_TYPE DeviceType,
IN ULONG AdditionalFlags)
{
OBJECT_ATTRIBUTES ObjectAttributes;
IO_STATUS_BLOCK IoStatus;
PDEVICE_EXTENSION DeviceExtension;
UNICODE_STRING DeviceName;
PDEVICE_OBJECT DeviceObject;
HANDLE FileHandle;
NTSTATUS Status;
/* Assume failure */
if (NewDeviceObject) *NewDeviceObject = NULL;
/* Setup the attributes */
RtlInitUnicodeString(&DeviceName, FsName);
InitializeObjectAttributes(&ObjectAttributes,
&DeviceName,
OBJ_CASE_INSENSITIVE,
0,
NULL);
/* Open the device */
Status = ZwCreateFile(&FileHandle,
SYNCHRONIZE,
&ObjectAttributes,
&IoStatus,
NULL,
0,
FILE_SHARE_READ | FILE_SHARE_WRITE,
FILE_OPEN,
0,
NULL,
0);
if (NT_SUCCESS(Status))
{
/* We succeeded, close the handle */
ZwClose(FileHandle);
}
else if (Status != STATUS_OBJECT_NAME_NOT_FOUND)
{
/* We failed with anything else then what we want to fail with */
Status = STATUS_SUCCESS;
}
/* If we succeeded, there's no point in trying this again */
if (NT_SUCCESS(Status)) return STATUS_IMAGE_ALREADY_LOADED;
/* Create recognizer device object */
RtlInitUnicodeString(&DeviceName, RecognizerName);
Status = IoCreateDevice(DriverObject,
sizeof(DEVICE_EXTENSION),
&DeviceName,
DeviceType,
0,
FALSE,
&DeviceObject);
if (NT_SUCCESS(Status))
{
/* Set additional flags in the device object */
DeviceObject->Flags |= AdditionalFlags;
/* Get the device extension and set it up */
DeviceExtension = DeviceObject->DeviceExtension;
DeviceExtension->FsType = FsType;
DeviceExtension->State = Pending;
/* Do we have a parent? */
if (ParentObject)
{
/* Link it in */
DeviceExtension->Alternate =
((PDEVICE_EXTENSION)ParentObject->DeviceExtension)->Alternate;
((PDEVICE_EXTENSION)ParentObject->DeviceExtension)->Alternate =
DeviceObject;
}
else
{
/* Otherwise, we're the only one */
DeviceExtension->Alternate = DeviceObject;
}
/* Return the DO if needed */
if (NewDeviceObject) *NewDeviceObject = DeviceObject;
/* Register the file system */
IoRegisterFileSystem(DeviceObject);
}
/* Return Status */
return Status;
}
NTSTATUS
NTAPI
DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
ULONG DeviceCount = 0;
NTSTATUS Status;
PDEVICE_OBJECT CdfsObject;
PDEVICE_OBJECT UdfsObject;
PAGED_CODE();
UNREFERENCED_PARAMETER(RegistryPath);
/* Page the entire driver */
MmPageEntireDriver(DriverEntry);
/* Allocate the lock */
FsRecLoadSync = ExAllocatePoolWithTag(NonPagedPool,
sizeof(KEVENT),
FSREC_TAG);
if (!FsRecLoadSync) return STATUS_INSUFFICIENT_RESOURCES;
/* Initialize it */
KeInitializeEvent(FsRecLoadSync, SynchronizationEvent, TRUE);
/* Setup the major functions */
DriverObject->MajorFunction[IRP_MJ_CREATE] = FsRecCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = FsRecClose;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = FsRecClose;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = FsRecFsControl;
DriverObject->DriverUnload = FsRecUnload;
/* Register CDFS for CDs */
Status = FsRecRegisterFs(DriverObject,
NULL,
&CdfsObject,
L"\\Cdfs",
L"\\FileSystem\\CdfsRecognizer",
FS_TYPE_CDFS,
FILE_DEVICE_CD_ROM_FILE_SYSTEM,
DO_LOW_PRIORITY_FILESYSTEM);
if (NT_SUCCESS(Status)) DeviceCount++;
/* Register CDFS for HDDs */
Status = FsRecRegisterFs(DriverObject,
CdfsObject,
NULL,
L"\\CdfsHdd",
L"\\FileSystem\\CdfsHddRecognizer",
FS_TYPE_CDFS,
FILE_DEVICE_DISK_FILE_SYSTEM,
DO_LOW_PRIORITY_FILESYSTEM);
if (NT_SUCCESS(Status)) DeviceCount++;
/* Register UDFS for CDs */
Status = FsRecRegisterFs(DriverObject,
NULL,
&UdfsObject,
L"\\UdfsCdRom",
L"\\FileSystem\\UdfsCdRomRecognizer",
FS_TYPE_UDFS,
FILE_DEVICE_CD_ROM_FILE_SYSTEM,
0);
if (NT_SUCCESS(Status)) DeviceCount++;
/* Register UDFS for HDDs */
Status = FsRecRegisterFs(DriverObject,
UdfsObject,
NULL,
L"\\UdfsDisk",
L"\\FileSystem\\UdfsDiskRecognizer",
FS_TYPE_UDFS,
FILE_DEVICE_DISK_FILE_SYSTEM,
0);
if (NT_SUCCESS(Status)) DeviceCount++;
/* Register FAT */
Status = FsRecRegisterFs(DriverObject,
NULL,
NULL,
L"\\Fat",
L"\\FileSystem\\FatRecognizer",
FS_TYPE_VFAT,
FILE_DEVICE_DISK_FILE_SYSTEM,
0);
if (NT_SUCCESS(Status)) DeviceCount++;
/* Register NTFS */
Status = FsRecRegisterFs(DriverObject,
NULL,
NULL,
L"\\Ntfs",
L"\\FileSystem\\NtfsRecognizer",
FS_TYPE_NTFS,
FILE_DEVICE_DISK_FILE_SYSTEM,
0);
if (NT_SUCCESS(Status)) DeviceCount++;
/* Register EXT2 */
Status = FsRecRegisterFs(DriverObject,
NULL,
NULL,
L"\\Ext2fs",
L"\\FileSystem\\Ext2Recognizer",
FS_TYPE_EXT2,
FILE_DEVICE_DISK_FILE_SYSTEM,
0);
if (NT_SUCCESS(Status)) DeviceCount++;
/* Register BTRFS */
Status = FsRecRegisterFs(DriverObject,
NULL,
NULL,
L"\\Btrfs",
L"\\FileSystem\\BtrfsRecognizer",
FS_TYPE_BTRFS,
FILE_DEVICE_DISK_FILE_SYSTEM,
0);
if (NT_SUCCESS(Status)) DeviceCount++;
/* Register REISERFS */
Status = FsRecRegisterFs(DriverObject,
NULL,
NULL,
L"\\Reiserfs",
L"\\FileSystem\\ReiserfsRecognizer",
FS_TYPE_REISERFS,
FILE_DEVICE_DISK_FILE_SYSTEM,
0);
if (NT_SUCCESS(Status)) DeviceCount++;
/* Register FFS */
Status = FsRecRegisterFs(DriverObject,
NULL,
NULL,
L"\\ffs",
L"\\FileSystem\\FfsRecognizer",
FS_TYPE_FFS,
FILE_DEVICE_DISK_FILE_SYSTEM,
0);
if (NT_SUCCESS(Status)) DeviceCount++;
/* Return appropriate Status */
return (DeviceCount > 0) ? STATUS_SUCCESS : STATUS_IMAGE_ALREADY_LOADED;
}
/* EOF */