vfdfmt.c

Go to the documentation of this file.

/*
    vfdfmt.c

    Virtual Floppy Drive for Windows NT platform
    Kernel mode driver: disk format functions

    Copyright (C) 2003-2005 Ken Kato
*/

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

#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, VfdFormatCheck)
#pragma alloc_text(PAGE, VfdFormatTrack)
#endif  // ALLOC_PRAGMA

//
//  Media geometry constant table
//
//  MediaTypes values added since Win NT DDK
#ifndef F3_640_512
#define F3_640_512              (MEDIA_TYPE)14
#endif
#ifndef F3_1Pt2_512
#define F3_1Pt2_512             (MEDIA_TYPE)17
#endif

#ifndef __REACTOS__
extern DISK_GEOMETRY const geom_tbl[VFD_MEDIA_MAX] = {
    {{ 80 },    F3_1Pt44_512,   2,  18, VFD_BYTES_PER_SECTOR }, // default
    {{ 40 },    F5_160_512,     1,  8,  VFD_BYTES_PER_SECTOR }, // 160K
    {{ 40 },    F5_180_512,     1,  9,  VFD_BYTES_PER_SECTOR }, // 180K
    {{ 40 },    F5_320_512,     2,  8,  VFD_BYTES_PER_SECTOR }, // 320K
    {{ 40 },    F5_360_512,     2,  9,  VFD_BYTES_PER_SECTOR }, // 360K
    {{ 80 },    F3_640_512,     2,  8,  VFD_BYTES_PER_SECTOR }, // 640k
    {{ 80 },    F5_640_512,     2,  8,  VFD_BYTES_PER_SECTOR }, // 640k
    {{ 80 },    F3_720_512,     2,  9,  VFD_BYTES_PER_SECTOR }, // 720K
    {{ 80 },    F5_720_512,     2,  9,  VFD_BYTES_PER_SECTOR }, // 720K
    {{ 82 },    RemovableMedia, 2,  10, VFD_BYTES_PER_SECTOR }, // 820K
    {{ 80 },    F3_1Pt2_512,    2,  15, VFD_BYTES_PER_SECTOR }, // 1200K
    {{ 80 },    F5_1Pt2_512,    2,  15, VFD_BYTES_PER_SECTOR }, // 1200K
    {{ 80 },    F3_1Pt44_512,   2,  18, VFD_BYTES_PER_SECTOR }, // 1440K
    {{ 80 },    RemovableMedia, 2,  21, VFD_BYTES_PER_SECTOR }, // 1680K DMF
    {{ 82 },    RemovableMedia, 2,  21, VFD_BYTES_PER_SECTOR }, // 1720K DMF
    {{ 80 },    F3_2Pt88_512,   2,  36, VFD_BYTES_PER_SECTOR }, // 2880K
#else
DISK_GEOMETRY const geom_tbl[VFD_MEDIA_MAX] = {
    {{ {80} },  F3_1Pt44_512,   2,  18, VFD_BYTES_PER_SECTOR }, // default
    {{ {40} },  F5_160_512,     1,  8,  VFD_BYTES_PER_SECTOR }, // 160K
    {{ {40} },  F5_180_512,     1,  9,  VFD_BYTES_PER_SECTOR }, // 180K
    {{ {40} },  F5_320_512,     2,  8,  VFD_BYTES_PER_SECTOR }, // 320K
    {{ {40} },  F5_360_512,     2,  9,  VFD_BYTES_PER_SECTOR }, // 360K
    {{ {80} },  F3_640_512,     2,  8,  VFD_BYTES_PER_SECTOR }, // 640k
    {{ {80} },  F5_640_512,     2,  8,  VFD_BYTES_PER_SECTOR }, // 640k
    {{ {80} },  F3_720_512,     2,  9,  VFD_BYTES_PER_SECTOR }, // 720K
    {{ {80} },  F5_720_512,     2,  9,  VFD_BYTES_PER_SECTOR }, // 720K
    {{ {82} },  RemovableMedia, 2,  10, VFD_BYTES_PER_SECTOR }, // 820K
    {{ {80} },  F3_1Pt2_512,    2,  15, VFD_BYTES_PER_SECTOR }, // 1200K
    {{ {80} },  F5_1Pt2_512,    2,  15, VFD_BYTES_PER_SECTOR }, // 1200K
    {{ {80} },  F3_1Pt44_512,   2,  18, VFD_BYTES_PER_SECTOR }, // 1440K
    {{ {80} },  RemovableMedia, 2,  21, VFD_BYTES_PER_SECTOR }, // 1680K DMF
    {{ {82} },  RemovableMedia, 2,  21, VFD_BYTES_PER_SECTOR }, // 1720K DMF
    {{ {80} },  F3_2Pt88_512,   2,  36, VFD_BYTES_PER_SECTOR }, // 2880K
#endif
};

//
//  Parameter check for IOCTL_DISK_FORMAT_TRACK and IOCTL_DISK_FORMAT_TRACK_EX
//
NTSTATUS
VfdFormatCheck(
    PDEVICE_EXTENSION           DeviceExtension,
    PFORMAT_PARAMETERS          FormatParams,
    ULONG                       InputLength,
    ULONG                       ControlCode)
{
    const DISK_GEOMETRY         *geometry;

    //  Check media status

    if (!DeviceExtension->FileHandle &&
        !DeviceExtension->FileBuffer) {
        return STATUS_NO_MEDIA_IN_DEVICE;
    }

    //  Media is writable?

    if (DeviceExtension->MediaFlags & VFD_FLAG_WRITE_PROTECTED) {
        return STATUS_MEDIA_WRITE_PROTECTED;
    }

    //  Check input parameter size

    if (InputLength < sizeof(FORMAT_PARAMETERS)) {
        return STATUS_INVALID_PARAMETER;
    }

    //  Choose appropriate DISK_GEOMETRY for current image size

    geometry = DeviceExtension->Geometry;

    if (!geometry) {
        return STATUS_DRIVER_INTERNAL_ERROR;
    }

    //  Input parameter sanity check

    if ((FormatParams->StartHeadNumber      > geometry->TracksPerCylinder - 1)  ||
        (FormatParams->EndHeadNumber        > geometry->TracksPerCylinder - 1)  ||
        (FormatParams->StartCylinderNumber  > geometry->Cylinders.LowPart)      ||
        (FormatParams->EndCylinderNumber    > geometry->Cylinders.LowPart)      ||
        (FormatParams->EndCylinderNumber    < FormatParams->StartCylinderNumber))
    {
        return STATUS_INVALID_PARAMETER;
    }

    //  If this is an EX request then make a couple of extra checks

    if (ControlCode == IOCTL_DISK_FORMAT_TRACKS_EX) {

        PFORMAT_EX_PARAMETERS exparams;

        if (InputLength < sizeof(FORMAT_EX_PARAMETERS)) {
            return STATUS_INVALID_PARAMETER;
        }

        exparams = (PFORMAT_EX_PARAMETERS)FormatParams;

        if (InputLength <
            FIELD_OFFSET(FORMAT_EX_PARAMETERS, SectorNumber) +
            exparams->SectorsPerTrack * sizeof(USHORT))
        {
            return STATUS_INVALID_PARAMETER;
        }

        if (exparams->FormatGapLength > geometry->SectorsPerTrack ||
            exparams->SectorsPerTrack != geometry->SectorsPerTrack)
        {
            return STATUS_INVALID_PARAMETER;
        }
    }

    return STATUS_SUCCESS;
}

//
//  Format tracks
//  Actually, just fills specified range of tracks with fill characters
//
NTSTATUS
VfdFormatTrack(
    IN PDEVICE_EXTENSION        DeviceExtension,
    IN PFORMAT_PARAMETERS       FormatParams)
{
    const DISK_GEOMETRY         *geometry;
    ULONG                       track_length;
    PUCHAR                      format_buffer;
    LARGE_INTEGER               start_offset;
    LARGE_INTEGER               end_offset;
    NTSTATUS                    status;

    VFDTRACE(0, ("[VFD] VfdFormatTrack - IN\n"));

    ASSERT(DeviceExtension != NULL);

    geometry = DeviceExtension->Geometry;

    if (!geometry) {
        return STATUS_DRIVER_INTERNAL_ERROR;
    }

    track_length = geometry->BytesPerSector * geometry->SectorsPerTrack;

    format_buffer = (PUCHAR)ExAllocatePoolWithTag(
        PagedPool, track_length, VFD_POOL_TAG);

    if (format_buffer == NULL) {
        VFDTRACE(0, ("[VFD] cannot allocate a format buffer\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlFillMemory(format_buffer, track_length, VFD_FORMAT_FILL_DATA);

    start_offset.QuadPart =
        FormatParams->StartCylinderNumber * geometry->TracksPerCylinder * track_length +
        FormatParams->StartHeadNumber * track_length;

    end_offset.QuadPart =
        FormatParams->EndCylinderNumber * geometry->TracksPerCylinder * track_length +
        FormatParams->EndHeadNumber * track_length;

    do {
        if (DeviceExtension->FileHandle) {
            IO_STATUS_BLOCK io_status;

            status = ZwWriteFile(
                DeviceExtension->FileHandle,
                NULL,
                NULL,
                NULL,
                &io_status,
                format_buffer,
                track_length,
                &start_offset,
                NULL);

            if (!NT_SUCCESS(status)) {
                VFDTRACE(0, ("[VFD] ZwWriteFile - %s\n",
                    GetStatusName(status)));
                break;
            }
        }
        else {
            RtlMoveMemory(
                DeviceExtension->FileBuffer + start_offset.QuadPart,
                format_buffer,
                track_length);

            status = STATUS_SUCCESS;
        }

        start_offset.QuadPart += track_length;
    }
    while (start_offset.QuadPart <= end_offset.QuadPart);

    ExFreePool(format_buffer);

    VFDTRACE(0, ("[VFD] VfdFormatTrack - OUT\n"));

    return status;
}