--- /dev/null
+/*
+ vfddrv.c
+
+ Virtual Floppy Drive for Windows NT platform
+ Kernel mode driver: miscellaneous driver functions
+
+ Copyright (C) 2003-2005 Ken Kato
+*/
+
+#include "imports.h"
+#include "vfddrv.h"
+#include "vfddbg.h"
+
+//
+// driver reinitialize routine
+// -- create a drive letter for each device
+//
+#ifdef __cplusplus
+extern "C"
+#endif // __cplusplus
+static VOID
+NTAPI
+VfdReinitialize(
+ IN PDRIVER_OBJECT DriverObject,
+ IN PVOID Context,
+ IN ULONG Count);
+
+//
+// specify code segment
+//
+#ifdef ALLOC_PRAGMA
+#pragma alloc_text(INIT, DriverEntry)
+#pragma alloc_text(PAGE, VfdReinitialize)
+#pragma alloc_text(PAGE, VfdUnloadDriver)
+#pragma alloc_text(PAGE, VfdCreateClose)
+#pragma alloc_text(PAGE, VfdCopyUnicode)
+#pragma alloc_text(PAGE, VfdFreeUnicode)
+#endif // ALLOC_PRAGMA
+
+//
+// operating system version
+//
+#ifndef __REACTOS__
+extern ULONG OsMajorVersion = 0;
+extern ULONG OsMinorVersion = 0;
+extern ULONG OsBuildNumber = 0;
+#else
+ULONG OsMajorVersion = 0;
+ULONG OsMinorVersion = 0;
+ULONG OsBuildNumber = 0;
+#endif
+
+//
+// Trace level flag
+//
+#if DBG
+#ifndef __REACTOS__
+extern ULONG TraceFlags = (ULONG)-1;
+#else
+ULONG TraceFlags = (ULONG)-1;
+#endif
+#endif // DBG
+
+//
+// Driver Entry routine
+//
+NTSTATUS
+NTAPI
+DriverEntry (
+ IN PDRIVER_OBJECT DriverObject,
+ IN PUNICODE_STRING RegistryPath)
+{
+ NTSTATUS status;
+ PVFD_DRIVER_EXTENSION driver_extension;
+ ULONG number_of_devices = VFD_DEFAULT_DEVICES;
+
+ ASSERT(DriverObject);
+
+ // Get operating system version
+
+ PsGetVersion(&OsMajorVersion, &OsMinorVersion, &OsBuildNumber, NULL);
+
+#ifdef VFD_PNP
+#define VFD_PNP_TAG "(Plug & Play version)"
+#else
+#define VFD_PNP_TAG
+#endif
+
+ VFDTRACE(0, ("[VFD] %s %s" VFD_PNP_TAG "\n",
+ VFD_PRODUCT_NAME, VFD_DRIVER_VERSION_STR));
+
+ VFDTRACE(0,
+ ("[VFD] Running on Windows NT %lu.%lu build %lu\n",
+ OsMajorVersion, OsMinorVersion, OsBuildNumber));
+
+ VFDTRACE(0,
+ ("[VFD] Build Target Environment: %d\n", VER_PRODUCTBUILD));
+
+#ifdef VFD_PNP
+
+ // Create device_extension for the driver object to store driver specific
+ // information. Device specific information are stored in device extension
+ // for each device object.
+
+ status = IoAllocateDriverObjectExtension(
+ DriverObject,
+ VFD_DRIVER_EXTENSION_ID,
+ sizeof(VFD_DRIVER_EXTENSION),
+ &driver_extension);
+
+ if(!NT_SUCCESS(status)) {
+ VFDTRACE(0, ("[VFD] IoAllocateDriverObjectExtension - %s\n",
+ GetStatusName(status)));
+ return status;
+ }
+
+#else // VFD_PNP
+
+ // Windows NT doesn't have the IoAllocateDriverObjectExtension
+ // function and I think there's little point in making a non-PnP
+ // driver incompatible with Windows NT.
+
+ driver_extension = (PVFD_DRIVER_EXTENSION)ExAllocatePoolWithTag(
+ PagedPool, sizeof(VFD_DRIVER_EXTENSION), VFD_POOL_TAG);
+
+ if (!driver_extension) {
+ VFDTRACE(0, ("[VFD] failed to allocate the driver extension.\n"));
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+#endif // VFD_PNP
+
+ RtlZeroMemory(driver_extension, sizeof(VFD_DRIVER_EXTENSION));
+
+ //
+ // Copy the registry path into the driver extension so we can use it later
+ //
+ if (VfdCopyUnicode(&(driver_extension->RegistryPath), RegistryPath)) {
+
+ //
+ // Read config values from the registry
+ //
+ RTL_QUERY_REGISTRY_TABLE params[3];
+ ULONG default_devs = VFD_DEFAULT_DEVICES;
+#if DBG
+ ULONG default_trace = (ULONG)-1;
+#endif
+
+ RtlZeroMemory(params, sizeof(params));
+
+ VFDTRACE(0, ("[VFD] Registry Path: %ws\n",
+ driver_extension->RegistryPath.Buffer));
+
+ params[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
+ params[0].Name = VFD_REG_DEVICE_NUMBER;
+ params[0].EntryContext = &number_of_devices;
+ params[0].DefaultType = REG_DWORD;
+ params[0].DefaultData = &default_devs;
+ params[0].DefaultLength = sizeof(ULONG);
+
+#if DBG
+ params[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
+ params[1].Name = VFD_REG_TRACE_FLAGS;
+ params[1].EntryContext = &TraceFlags;
+ params[1].DefaultType = REG_DWORD;
+ params[1].DefaultData = &default_trace;
+ params[1].DefaultLength = sizeof(ULONG);
+#endif // DBG
+
+ status = RtlQueryRegistryValues(
+ RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
+ driver_extension->RegistryPath.Buffer,
+ params, NULL, NULL);
+
+ if (!NT_SUCCESS(status) ||
+ number_of_devices == 0 ||
+ number_of_devices > VFD_MAXIMUM_DEVICES) {
+ number_of_devices = VFD_DEFAULT_DEVICES;
+ }
+
+ VFDTRACE(0,("[VFD] NumberOfDevices = %lu\n", number_of_devices));
+ VFDTRACE(0,("[VFD] TraceFlags = 0x%08x\n", TraceFlags));
+ }
+ else {
+ VFDTRACE(0, ("[VFD] failed to allocate the registry path buffer.\n"));
+ // this error is not fatal
+ }
+
+ //
+ // Create VFD device objects
+ //
+ do {
+#ifdef VFD_PNP
+ status = VfdCreateDevice(DriverObject, NULL);
+#else // VFD_PNP
+ status = VfdCreateDevice(DriverObject, driver_extension);
+#endif // VFD_PNP
+
+ if (!NT_SUCCESS(status)) {
+ break;
+ }
+ }
+ while (driver_extension->NumberOfDevices < number_of_devices);
+
+ if (!driver_extension->NumberOfDevices) {
+
+ // Failed to create even one device
+
+ VfdFreeUnicode(&(driver_extension->RegistryPath));
+
+ return status;
+ }
+
+ // Setup dispatch table
+
+ DriverObject->MajorFunction[IRP_MJ_CREATE] = VfdCreateClose;
+ DriverObject->MajorFunction[IRP_MJ_CLOSE] = VfdCreateClose;
+ DriverObject->MajorFunction[IRP_MJ_READ] = VfdReadWrite;
+ DriverObject->MajorFunction[IRP_MJ_WRITE] = VfdReadWrite;
+ DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = VfdDeviceControl;
+
+#ifdef VFD_PNP
+ DriverObject->MajorFunction[IRP_MJ_PNP] = VfdPlugAndPlay;
+ DriverObject->MajorFunction[IRP_MJ_POWER] = VfdPowerControl;
+ DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = VfdSystemControl;
+ DriverObject->DriverExtension->AddDevice = VfdAddDevice;
+#endif // VFDPNP
+
+ DriverObject->DriverUnload = VfdUnloadDriver;
+
+ // Register the driver reinitialize routine to be called
+ // *after* the DriverEntry routine returns
+
+ IoRegisterDriverReinitialization(
+ DriverObject, VfdReinitialize, NULL);
+
+ VFDTRACE(VFDINFO,
+ ("[VFD] driver initialized with %lu devices.\n",
+ driver_extension->NumberOfDevices));
+
+ return STATUS_SUCCESS;
+}
+
+//
+// Driver unload routine
+// Cleans up the device objects and other resources
+//
+VOID
+NTAPI
+VfdUnloadDriver (
+ IN PDRIVER_OBJECT DriverObject)
+{
+ PDEVICE_OBJECT device_object;
+ PVFD_DRIVER_EXTENSION driver_extension;
+
+ VFDTRACE(VFDINFO, ("[VFD] VfdUnloadDriver - IN\n"));
+
+ device_object = DriverObject->DeviceObject;
+
+#ifdef VFD_PNP
+ driver_extension = IoGetDriverObjectExtension(
+ DriverObject, VFD_DRIVER_EXTENSION_ID);
+#else
+ if (device_object && device_object->DeviceExtension) {
+ driver_extension =
+ ((PDEVICE_EXTENSION)(device_object->DeviceExtension))->DriverExtension;
+ }
+ else {
+ driver_extension = NULL;
+ }
+#endif // VFD_PNP
+
+ //
+ // Delete all remaining device objects
+ //
+ while (device_object) {
+
+ PDEVICE_OBJECT next_device = device_object->NextDevice;
+
+ VfdDeleteDevice(device_object);
+
+ device_object = next_device;
+ }
+
+ //
+ // Release the driver extension and the registry path buffer
+ //
+ if (driver_extension) {
+
+ if (driver_extension->RegistryPath.Buffer) {
+ VFDTRACE(0, ("[VFD] Releasing the registry path buffer\n"));
+ ExFreePool(driver_extension->RegistryPath.Buffer);
+ }
+
+#ifndef VFD_PNP
+ // The system takes care of freeing the driver extension
+ // allocated with IoAllocateDriverObjectExtension in a PnP driver.
+ VFDTRACE(0, ("[VFD] Releasing the driver extension\n"));
+ ExFreePool(driver_extension);
+#endif // VFD_PNP
+ }
+
+ VFDTRACE(VFDINFO, ("[VFD] VfdUnloadDriver - OUT\n"));
+}
+
+//
+// IRP_MJ_CREATE and IRP_MJ_CLOSE handler
+// Really nothing to do here...
+//
+NTSTATUS
+NTAPI
+VfdCreateClose (
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+#if DBG
+ if (DeviceObject && DeviceObject->DeviceExtension &&
+ ((PDEVICE_EXTENSION)DeviceObject->DeviceExtension)->DeviceName.Buffer) {
+
+ VFDTRACE(VFDINFO, ("[VFD] %-40s %ws\n",
+ GetMajorFuncName(IoGetCurrentIrpStackLocation(Irp)->MajorFunction),
+ ((PDEVICE_EXTENSION)DeviceObject->DeviceExtension)->DeviceName.Buffer));
+ }
+ else {
+ VFDTRACE(VFDINFO, ("[VFD] %-40s %p\n",
+ GetMajorFuncName(IoGetCurrentIrpStackLocation(Irp)->MajorFunction),
+ DeviceObject));
+ }
+#endif // DBG
+
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+ Irp->IoStatus.Information = FILE_OPENED;
+
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+
+ return STATUS_SUCCESS;
+}
+
+//
+// Called after the DriverEntry routine has returned
+// (Re)Create a persistent drive letter for each device
+//
+VOID
+NTAPI
+VfdReinitialize(
+ IN PDRIVER_OBJECT DriverObject,
+ IN PVOID Context,
+ IN ULONG Count)
+{
+ PDEVICE_OBJECT device_object;
+ PDEVICE_EXTENSION device_extension;
+
+ UNREFERENCED_PARAMETER(Context);
+ UNREFERENCED_PARAMETER(Count);
+
+ VFDTRACE(VFDINFO, ("[VFD] VfdReinitialize - IN\n"));
+
+ device_object = DriverObject->DeviceObject;
+
+ while (device_object) {
+ device_extension = (PDEVICE_EXTENSION)device_object->DeviceExtension;
+
+#ifdef VFD_MOUNT_MANAGER
+ if (OsMajorVersion >= 5) {
+ // Windows 2000 / XP
+ // Notify the mount manager of a VFD volume arrival
+ VfdMountMgrNotifyVolume(device_extension);
+
+ if (device_extension->DriveLetter) {
+ // Create a drive letter via the mount manager.
+ // The mount manager may have created a drive letter
+ // in response to the volume arrival notification above.
+ // In that case, the following call just fails.
+ VfdMountMgrMountPoint(
+ device_extension, device_extension->DriveLetter);
+ // ignoring the error for it is not fatal here
+ }
+ }
+ else
+#endif // VFD_MOUNT_MANAGER
+ {
+ // Windows NT style drive letter assignment
+ // Simply create a symbolic link here
+ if (device_extension->DriveLetter) {
+ VfdSetLink(
+ device_extension, device_extension->DriveLetter);
+ // ignoring the error for it is not fatal here
+ }
+ }
+
+ device_object = device_object->NextDevice;
+ }
+
+ VFDTRACE(VFDINFO, ("[VFD] VfdReinitialize - OUT\n"));
+}
+
+//
+// Device dedicated thread routine
+// Dispatch read, write and device I/O request
+// redirected from the driver dispatch routines
+//
+VOID
+NTAPI
+VfdDeviceThread (
+ IN PVOID ThreadContext)
+{
+ PDEVICE_OBJECT device_object;
+ PDEVICE_EXTENSION device_extension;
+ PLIST_ENTRY request;
+ PIRP irp;
+ PIO_STACK_LOCATION io_stack;
+
+ ASSERT(ThreadContext != NULL);
+
+ device_object = (PDEVICE_OBJECT)ThreadContext;
+
+ device_extension = (PDEVICE_EXTENSION)device_object->DeviceExtension;
+
+ KeSetPriorityThread(KeGetCurrentThread(), LOW_REALTIME_PRIORITY);
+
+ for (;;) {
+ // wait for the request event to be signalled
+ KeWaitForSingleObject(
+ &device_extension->RequestEvent,
+ Executive,
+ KernelMode,
+ FALSE,
+ NULL);
+
+ // terminate request ?
+ if (device_extension->TerminateThread) {
+ VFDTRACE(0, ("[VFD] Exitting the I/O thread\n"));
+ PsTerminateSystemThread(STATUS_SUCCESS);
+ }
+
+ // perform requested tasks
+
+ while ((request = ExInterlockedRemoveHeadList(
+ &device_extension->ListHead,
+ &device_extension->ListLock)) != NULL)
+ {
+ irp = CONTAINING_RECORD(request, IRP, Tail.Overlay.ListEntry);
+
+ io_stack = IoGetCurrentIrpStackLocation(irp);
+
+ irp->IoStatus.Information = 0;
+
+ switch (io_stack->MajorFunction) {
+ case IRP_MJ_READ:
+ VfdReadData(device_extension, irp,
+ io_stack->Parameters.Read.Length,
+ &io_stack->Parameters.Read.ByteOffset);
+ break;
+
+ case IRP_MJ_WRITE:
+ VfdWriteData(device_extension, irp,
+ io_stack->Parameters.Write.Length,
+ &io_stack->Parameters.Write.ByteOffset);
+ break;
+
+ case IRP_MJ_DEVICE_CONTROL:
+ VfdIoCtlThread(device_extension, irp,
+ io_stack->Parameters.DeviceIoControl.IoControlCode);
+ break;
+
+ default:
+ // This shouldn't happen...
+ VFDTRACE(0,
+ ("[VFD] %s passed to the I/O thread\n",
+ GetMajorFuncName(io_stack->MajorFunction)));
+
+ irp->IoStatus.Status = STATUS_DRIVER_INTERNAL_ERROR;
+ }
+
+ IoCompleteRequest(irp,
+ (CCHAR)(NT_SUCCESS(irp->IoStatus.Status) ?
+ IO_DISK_INCREMENT : IO_NO_INCREMENT));
+
+#ifdef VFD_PNP
+ IoReleaseRemoveLock(&device_extension->RemoveLock, irp);
+#endif // VFD_PNP
+ } // while
+ } // for (;;)
+}
+
+//
+// Copy a UNICODE_STRING adding a trailing NULL characer
+//
+PWSTR VfdCopyUnicode(
+ PUNICODE_STRING dst,
+ PUNICODE_STRING src)
+{
+ RtlZeroMemory(dst, sizeof(UNICODE_STRING));
+
+ dst->MaximumLength =
+ (USHORT)(src->MaximumLength + sizeof(UNICODE_NULL));
+
+ dst->Buffer = (PWSTR)ExAllocatePoolWithTag(
+ PagedPool, dst->MaximumLength, VFD_POOL_TAG);
+
+ if(dst->Buffer) {
+ dst->Length = src->Length;
+ RtlZeroMemory(dst->Buffer, dst->MaximumLength);
+
+ if (src->Length) {
+ RtlCopyMemory(dst->Buffer, src->Buffer, src->Length);
+ }
+ }
+
+ return dst->Buffer;
+}
+
+//
+// Free a UNICODE_STRING buffer
+//
+VOID VfdFreeUnicode(
+ PUNICODE_STRING str)
+{
+ if (str->Buffer) {
+ ExFreePool(str->Buffer);
+ }
+ RtlZeroMemory(str, sizeof(UNICODE_STRING));
+}
projects / reactos.git / blobdiff