vfddev.c

Go to the documentation of this file.

/*
    vfddev.c
 
    Virtual Floppy Drive for Windows NT platform
    Kernel mode driver: device create/delete functions
 
    Copyright (C) 2003-2005 Ken Kato
*/
 
#include "imports.h"
#include "vfddrv.h"
#include "vfddbg.h"
 
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, VfdCreateDevice)
#pragma alloc_text(PAGE, VfdDeleteDevice)
#endif  // ALLOC_PRAGMA
 
//
//  Create a VFD device object
//
NTSTATUS
VfdCreateDevice(
    IN PDRIVER_OBJECT       DriverObject,
    OUT PVOID               Parameter)
{
    NTSTATUS                status;
    ULONG                   physical_num;
 
    UNICODE_STRING          unicode_name;
    WCHAR                   name_buffer[40];
 
    PVFD_DRIVER_EXTENSION   driver_extension    = NULL;
    PDEVICE_OBJECT          device_object       = NULL;
    PDEVICE_EXTENSION       device_extension    = NULL;
    HANDLE                  thread_handle       = NULL;
 
    VFDTRACE(VFDINFO | VFDDEV, ("[VFD] VfdCreateDevice - IN\n"));
 
#ifdef VFD_PNP
 
    //  Get the driver device_extension for the driver object
    driver_extension = IoGetDriverObjectExtension(
        DriverObject, VFD_DRIVER_EXTENSION_ID);
 
#else   // VFD_PNP
 
    //  The driver device_extension is passed as the Parameter
    driver_extension = (PVFD_DRIVER_EXTENSION)Parameter;
 
#endif  // VFD_PNP
 
    if (driver_extension == NULL) {
        VFDTRACE(VFDERR, ("[VFD] Failed to get the driver extension\n"));
        return STATUS_DRIVER_INTERNAL_ERROR;
    }
 
    //
    // Create a device object
    // \Device\Floppy<n>
    //
    physical_num = 0;
 
    do {
#ifndef __REACTOS__
        name_buffer[sizeof(name_buffer) - 1] = UNICODE_NULL;
 
        _snwprintf(name_buffer, sizeof(name_buffer) - 1,
            L"\\Device\\Floppy%lu", physical_num);
#else
        name_buffer[ARRAYSIZE(name_buffer) - 1] = UNICODE_NULL;
 
        _snwprintf(name_buffer, ARRAYSIZE(name_buffer) - 1,
            L"\\Device\\Floppy%lu", physical_num);
#endif
 
        RtlInitUnicodeString(&unicode_name, name_buffer);
 
        status = IoCreateDevice(
            DriverObject,
            sizeof(DEVICE_EXTENSION),
            &unicode_name,
            FILE_DEVICE_DISK,
            FILE_REMOVABLE_MEDIA | FILE_FLOPPY_DISKETTE | FILE_DEVICE_SECURE_OPEN,
            FALSE,
            &device_object);
 
        if (status != STATUS_OBJECT_NAME_EXISTS &&
            status != STATUS_OBJECT_NAME_COLLISION) {
            break;
        }
    }
    while (++physical_num < 100);
 
    if (!NT_SUCCESS(status)) {
        VFDTRACE(VFDERR,
            ("[VFD] IoCreateDevice() %s\n",
            GetStatusName(status)));
        return status;
    }
 
    IoGetConfigurationInformation()->FloppyCount++;
 
    VFDTRACE(VFDINFO | VFDDEV,
        ("[VFD] Created a device object %ws\n", name_buffer));
 
    //
    //  Initialize the device object / device extension
    //
 
    device_object->Flags |= DO_DIRECT_IO;
 
    device_extension = (PDEVICE_EXTENSION)device_object->DeviceExtension;
 
    RtlZeroMemory(device_extension, sizeof(DEVICE_EXTENSION));
 
    //  Store the back pointer to the device object
 
    device_extension->DeviceObject = device_object;
 
    //  Store the logical device number
 
    device_extension->DeviceNumber = driver_extension->NumberOfDevices;
 
    //  Store the device name
 
    if (!VfdCopyUnicode(&(device_extension->DeviceName), &unicode_name)) {
        VFDTRACE(VFDERR,
            ("[VFD] Failed to allocate device name buffer\n"));
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto cleanup;
    }
 
    //  set the default disk geometry (3.5" 1.44M)
 
    device_extension->Geometry = &geom_tbl[0];
 
    //  Create the interface link (\??\VirtualFD<n>)
 
#ifndef __REACTOS__
    name_buffer[sizeof(name_buffer) - 1] = UNICODE_NULL;
 
    _snwprintf(name_buffer, sizeof(name_buffer) - 1,
        L"\\??\\" VFD_DEVICE_BASENAME L"%lu",
        device_extension->DeviceNumber);
#else
    name_buffer[ARRAYSIZE(name_buffer) - 1] = UNICODE_NULL;
 
    _snwprintf(name_buffer, ARRAYSIZE(name_buffer) - 1,
        L"\\??\\" VFD_DEVICE_BASENAME L"%lu",
        device_extension->DeviceNumber);
#endif
 
    RtlInitUnicodeString(&unicode_name, name_buffer);
 
    status = IoCreateSymbolicLink(
        &unicode_name, &device_extension->DeviceName);
 
    if (!NT_SUCCESS(status)) {
        VFDTRACE(VFDERR,
            ("[VFD] IoCreateSymbolicLink(%ws) %s\n",
            name_buffer, GetStatusName(status)));
        goto cleanup;
    }
 
    VFDTRACE(VFDINFO|VFDDEV,
        ("[VFD] Created a symbolic link %ws\n", name_buffer));
 
    //  Prepare the IRP queue list for the device thread
 
    InitializeListHead(&device_extension->ListHead);
 
    KeInitializeSpinLock(&device_extension->ListLock);
 
    KeInitializeEvent(
        &device_extension->RequestEvent,
        SynchronizationEvent,
        FALSE);
 
    //  Create the device thread
 
    device_extension->TerminateThread = FALSE;
 
    status = PsCreateSystemThread(
        &thread_handle,
        (ACCESS_MASK) 0L,
        NULL,
        NULL,
        NULL,
        VfdDeviceThread,
        device_object);
 
    if (!NT_SUCCESS(status)) {
        VFDTRACE(VFDERR,
            ("[VFD] PsCreateSystemThread() %s\n",
            GetStatusName(status)));
        goto cleanup;
    }
 
    //  get a reference pointer to the thread
 
    status = ObReferenceObjectByHandle(
        thread_handle,
        THREAD_ALL_ACCESS,
        NULL,
        KernelMode,
        &device_extension->ThreadPointer,
        NULL);
 
    ZwClose(thread_handle);
 
    if (!NT_SUCCESS(status)) {
        VFDTRACE(VFDERR,
            ("[VFD] ObReferenceObjectByHandle() %s\n",
            GetStatusName(status)));
        goto cleanup;
    }
 
    //
    //  Load the persistent drive letter from the registry
    //
    if (driver_extension->RegistryPath.Buffer) {
        VfdLoadLink(device_extension,
            driver_extension->RegistryPath.Buffer);
        //  error is not fatal here
    }
 
    //  increment the number of devices in the driver extension
 
    driver_extension->NumberOfDevices++;
 
    if (DriverObject->DriverUnload) {
        //  not called from the DriverEntry routine
        device_object->Flags &= ~DO_DEVICE_INITIALIZING;
    }
 
#ifdef VFD_PNP
    if (Parameter) {
        //  return the device object pointer
        *(PDEVICE_OBJECT *)Parameter = device_object;
    }
#else   // VFD_PNP
    device_extension->DriverExtension = driver_extension;
#endif  // VFD_PNP
 
    VFDTRACE(VFDINFO | VFDDEV, ("[VFD] VfdCreateDevice - OK\n"));
 
    return STATUS_SUCCESS;
 
cleanup:
    //
    //  Something went wrong at one point
    //  Delete all resources that might be created in this function
    //
    if (thread_handle) {
 
        //  terminate the device thread
        device_extension->TerminateThread = TRUE;
 
        KeSetEvent(
            &device_extension->RequestEvent,
            (KPRIORITY) 0,
            FALSE);
 
        if (device_extension->ThreadPointer) {
            ObDereferenceObject(device_extension->ThreadPointer);
        }
    }
 
    VFDTRACE(VFDINFO|VFDDEV,
    ("[VFD] Deleting symbolic link %ws\n", name_buffer));
 
    IoDeleteSymbolicLink(&unicode_name);
 
    if (device_extension->DeviceName.Buffer) {
        VFDTRACE(VFDINFO|VFDDEV, ("[VFD] Deleting device %ws\n",
            device_extension->DeviceName.Buffer));
 
        ExFreePool(device_extension->DeviceName.Buffer);
    }
 
    IoDeleteDevice(device_object);
    IoGetConfigurationInformation()->FloppyCount--;
 
    VFDTRACE(VFDINFO|VFDDEV,
        ("[VFD] VfdCreateDevice - %s\n",
        GetStatusName(status)));
 
    return status;
}
 
//
//  delete a VFD device object
//
VOID
VfdDeleteDevice(
    IN PDEVICE_OBJECT           DeviceObject)
{
    PDEVICE_EXTENSION           device_extension;
    PVFD_DRIVER_EXTENSION       driver_extension;
    UNICODE_STRING              unicode_name;
    WCHAR                       name_buffer[40];
 
    VFDTRACE(VFDINFO|VFDDEV, ("[VFD] VfdDeleteDevice - IN\n"));
 
    device_extension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    //
    //  decrement the number of device in the driver extension
    //
#ifdef VFD_PNP
    driver_extension = IoGetDriverObjectExtension(
        DeviceObject->DriverObject, VFD_DRIVER_EXTENSION_ID);
#else   // VFD_PNP
    driver_extension = device_extension->DriverExtension;
#endif  // VFD_PNP
 
    if (driver_extension) {
        driver_extension->NumberOfDevices--;
    }
 
    //
    //  cleanup the device object
    //
 
    //  Terminate the device thread
 
    device_extension->TerminateThread = TRUE;
 
    KeSetEvent(
        &device_extension->RequestEvent,
        (KPRIORITY) 0,
        FALSE);
 
    KeWaitForSingleObject(
        device_extension->ThreadPointer,
        Executive,
        KernelMode,
        FALSE,
        NULL);
 
    ObDereferenceObject(
        device_extension->ThreadPointer);
 
    //  Delete security context object
 
    if (device_extension->SecurityContext) {
        SeDeleteClientSecurity(device_extension->SecurityContext);
        ExFreePool(device_extension->SecurityContext);
    }
 
    //  Close the image file or free the image buffer
 
    if (device_extension->FileHandle) {
        ZwClose(device_extension->FileHandle);
    }
 
    if (device_extension->FileBuffer) {
        ExFreePool(device_extension->FileBuffer);
    }
 
    //  Release the image path buffer
 
    if (device_extension->FileName.Buffer) {
        ExFreePool(device_extension->FileName.Buffer);
    }
 
    //  Remove the interface symbolic link
 
#ifndef __REACTOS__
    name_buffer[sizeof(name_buffer) - 1] = UNICODE_NULL;
 
    _snwprintf(name_buffer, sizeof(name_buffer) - 1,
        L"\\??\\" VFD_DEVICE_BASENAME L"%lu",
        device_extension->DeviceNumber);
#else
    name_buffer[ARRAYSIZE(name_buffer) - 1] = UNICODE_NULL;
 
    _snwprintf(name_buffer, ARRAYSIZE(name_buffer) - 1,
        L"\\??\\" VFD_DEVICE_BASENAME L"%lu",
        device_extension->DeviceNumber);
#endif
 
    RtlInitUnicodeString(&unicode_name, name_buffer);
 
    VFDTRACE(VFDINFO|VFDDEV,
        ("[VFD] Deleting link %ws\n", name_buffer));
 
    IoDeleteSymbolicLink(&unicode_name);
 
    //  Remove the persistent drive letter
 
    if (device_extension->DriveLetter) {
#ifdef VFD_MOUNT_MANAGER
        if (OsMajorVersion >= 5) {
            //  Request the mount manager to remove the drive letter.
            //  This will cause the mount manager to update its database
            //  and it won't arbitrarily assign the drive letter the next
            //  time the driver starts.
            VfdMountMgrMountPoint(device_extension, 0);
        }
        else
#endif  // VFD_MOUNT_MANAGER
        {
            //  Windows NT style drive letter handling
            //  Simply remove the symbolic link
            VfdSetLink(device_extension, 0);
        }
    }
 
    //  Release the device name buffer
 
    if (device_extension->DeviceName.Buffer) {
        VFDTRACE(VFDINFO|VFDDEV,
            ("[VFD] Deleting device %ws\n",
            device_extension->DeviceName.Buffer));
 
        ExFreePool(device_extension->DeviceName.Buffer);
    }
 
    //  Delete the device object
 
    IoDeleteDevice(DeviceObject);
    IoGetConfigurationInformation()->FloppyCount--;
 
    VFDTRACE(VFDINFO|VFDDEV,
        ("[VFD] VfdDeleteDevice - OUT\n"));
 
    return;
}