vfddrv.c File Reference

#include "imports.h"
#include "vfddrv.h"
#include "vfddbg.h"

Include dependency graph for vfddrv.c:

Go to the source code of this file.

Macros
#define	VFD_PNP_TAG

Functions
static VOID NTAPI	VfdReinitialize (IN PDRIVER_OBJECT DriverObject, IN PVOID Context, IN ULONG Count)
NTSTATUS NTAPI	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
VOID NTAPI	VfdUnloadDriver (IN PDRIVER_OBJECT DriverObject)
NTSTATUS NTAPI	VfdCreateClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	VfdDeviceThread (IN PVOID ThreadContext)
PWSTR	VfdCopyUnicode (PUNICODE_STRING dst, PUNICODE_STRING src)
VOID	VfdFreeUnicode (PUNICODE_STRING str)

Variables
ULONG	OsMajorVersion = 0
ULONG	OsMinorVersion = 0
ULONG	OsBuildNumber = 0

Macro Definition Documentation

VFD_PNP_TAG

#define VFD_PNP_TAG

Function Documentation

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	IN PDRIVER_OBJECT	DriverObject,
		IN PUNICODE_STRING	RegistryPath
	)

Definition at line 69 of file vfddrv.c.

{
    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;
}

VfdCopyUnicode()

PWSTR VfdCopyUnicode	(	PUNICODE_STRING	dst,
		PUNICODE_STRING	src
	)

Definition at line 489 of file vfddrv.c.

{
    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;
}

Referenced by DriverEntry(), and VfdCreateDevice().

VfdCreateClose()

NTSTATUS NTAPI VfdCreateClose	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 312 of file vfddrv.c.

{
#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;
}

Referenced by DriverEntry().

VfdDeviceThread()

VOID NTAPI VfdDeviceThread

(

IN PVOID

ThreadContext

)

Definition at line 404 of file vfddrv.c.

{
    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 (;;)
}

Referenced by VfdCreateDevice().

VfdFreeUnicode()

VOID VfdFreeUnicode

(

PUNICODE_STRING

str

)

Definition at line 516 of file vfddrv.c.

{
    if (str->Buffer) {
        ExFreePool(str->Buffer);
    }
    RtlZeroMemory(str, sizeof(UNICODE_STRING));
}

Referenced by DriverEntry().

VfdReinitialize()

VOID NTAPI VfdReinitialize ( IN PDRIVER_OBJECT  DriverObject, IN PVOID  Context, IN ULONG  Count  )

static

Definition at line 345 of file vfddrv.c.

{
    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"));
}

Referenced by DriverEntry().

VfdUnloadDriver()

VOID NTAPI VfdUnloadDriver

(

IN PDRIVER_OBJECT

DriverObject

)

Definition at line 250 of file vfddrv.c.

{
    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"));
}

Referenced by DriverEntry().

Variable Documentation

OsBuildNumber

ULONG OsBuildNumber = 0

extern

Referenced by DriverEntry().

OsMajorVersion

ULONG OsMajorVersion = 0

extern

Referenced by DriverEntry(), MmGetSystemAddressForMdlPrettySafe(), VfdDeleteDevice(), VfdDeviceControl(), VfdReinitialize(), and VfdSetLink().

OsMinorVersion

ULONG OsMinorVersion = 0

extern

Referenced by DriverEntry().