blockdev.c File Reference

#include "fs_rec.h"
#include <ntdddisk.h>
#include <ntddcdrm.h>
#include <debug.h>

Include dependency graph for blockdev.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
BOOLEAN NTAPI	FsRecGetDeviceSectors (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, OUT PLARGE_INTEGER SectorCount)
BOOLEAN NTAPI	FsRecGetDeviceSectorSize (IN PDEVICE_OBJECT DeviceObject, OUT PULONG SectorSize)
BOOLEAN NTAPI	FsRecReadBlock (IN PDEVICE_OBJECT DeviceObject, IN PLARGE_INTEGER Offset, IN ULONG Length, IN ULONG SectorSize, IN OUT PVOID *Buffer, OUT PBOOLEAN DeviceError OPTIONAL)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 17 of file blockdev.c.

Function Documentation

FsRecGetDeviceSectors()

BOOLEAN NTAPI FsRecGetDeviceSectors	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	SectorSize,
		OUT PLARGE_INTEGER	SectorCount
	)

Definition at line 24 of file blockdev.c.

{
    PARTITION_INFORMATION PartitionInfo;
    IO_STATUS_BLOCK IoStatusBlock;
    KEVENT Event;
    PIRP Irp;
    NTSTATUS Status;
    ULONG Remainder;
    PAGED_CODE();
 
    /* Only needed for disks */
    if (DeviceObject->DeviceType != FILE_DEVICE_DISK) return FALSE;
 
    /* Build the information IRP */
    KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
    Irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_PARTITION_INFO,
                                        DeviceObject,
                                        NULL,
                                        0,
                                        &PartitionInfo,
                                        sizeof(PARTITION_INFORMATION),
                                        FALSE,
                                        &Event,
                                        &IoStatusBlock);
    if (!Irp) return FALSE;
 
    /* Override verification */
    IoGetNextIrpStackLocation(Irp)->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
 
    /* Do the request */
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        /* Wait for completion */
        KeWaitForSingleObject(&Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        Status = IoStatusBlock.Status;
    }
 
    /* Fail if we couldn't get the data */
    if (!NT_SUCCESS(Status)) return FALSE;
 
    /* Otherwise, return the number of sectors */
    *SectorCount = RtlExtendedLargeIntegerDivide(PartitionInfo.PartitionLength,
                                                 SectorSize,
                                                 &Remainder);
    return TRUE;
}

Referenced by FsRecNtfsFsControl().

FsRecGetDeviceSectorSize()

BOOLEAN NTAPI FsRecGetDeviceSectorSize	(	IN PDEVICE_OBJECT	DeviceObject,
		OUT PULONG	SectorSize
	)

Definition at line 80 of file blockdev.c.

{
    DISK_GEOMETRY DiskGeometry;
    IO_STATUS_BLOCK IoStatusBlock;
    KEVENT Event;
    PIRP Irp;
    NTSTATUS Status;
    ULONG ControlCode;
    PAGED_CODE();
 
    /* Check what device we have */
    switch (DeviceObject->DeviceType)
    {
        case FILE_DEVICE_CD_ROM:
 
            /* Use the CD IOCTL */
            ControlCode = IOCTL_CDROM_GET_DRIVE_GEOMETRY;
            break;
 
        case FILE_DEVICE_DISK:
 
            /* Use the Disk IOCTL */
            ControlCode = IOCTL_DISK_GET_DRIVE_GEOMETRY;
            break;
 
        default:
 
            /* Invalid device type */
            return FALSE;
    }
 
    /* Build the information IRP */
    KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
    Irp = IoBuildDeviceIoControlRequest(ControlCode,
                                        DeviceObject,
                                        NULL,
                                        0,
                                        &DiskGeometry,
                                        sizeof(DISK_GEOMETRY),
                                        FALSE,
                                        &Event,
                                        &IoStatusBlock);
    if (!Irp) return FALSE;
 
    /* Override verification */
    IoGetNextIrpStackLocation(Irp)->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
 
    /* Do the request */
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        /* Wait for completion */
        KeWaitForSingleObject(&Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        Status = IoStatusBlock.Status;
    }
 
    /* Fail if we couldn't get the data */
    if (!NT_SUCCESS(Status)) return FALSE;
 
    /* Return the sector size if it's valid */
    if (!DiskGeometry.BytesPerSector) return FALSE;
    *SectorSize = DiskGeometry.BytesPerSector;
    return TRUE;
}

Referenced by FsRecBtrfsFsControl(), FsRecCdfsFsControl(), FsRecExtFsControl(), FsRecFatxFsControl(), FsRecFfsFsControl(), FsRecNtfsFsControl(), FsRecReiserfsFsControl(), FsRecUdfsFsControl(), and FsRecVfatFsControl().

FsRecReadBlock()

BOOLEAN NTAPI FsRecReadBlock	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PLARGE_INTEGER	Offset,
		IN ULONG	Length,
		IN ULONG	SectorSize,
		IN OUT PVOID *	Buffer,
		OUT PBOOLEAN DeviceError	OPTIONAL
	)

Definition at line 152 of file blockdev.c.

{
    IO_STATUS_BLOCK IoStatusBlock;
    KEVENT Event;
    PIRP Irp;
    NTSTATUS Status;
    PAGED_CODE();
 
    /* Assume failure */
    if (DeviceError) *DeviceError = FALSE;
 
    /* Check if the caller requested too little */
    if (Length < SectorSize)
    {
        /* Read at least the sector size */
        Length = SectorSize;
    }
    else
    {
        /* Otherwise, just round up the request to sector size */
        Length = ROUND_UP(Length, SectorSize);
    }
 
    /* Check if the caller gave us a buffer */
    if (!*Buffer)
    {
        /* He didn't, allocate one */
        *Buffer = ExAllocatePoolWithTag(NonPagedPool,
                                        ROUND_TO_PAGES(Length),
                                        FSREC_TAG);
        if (!*Buffer) return FALSE;
    }
 
    /* Build the IRP */
    KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
                                       DeviceObject,
                                       *Buffer,
                                       Length,
                                       Offset,
                                       &Event,
                                       &IoStatusBlock);
    if (!Irp) return FALSE;
 
    /* Override verification */
    IoGetNextIrpStackLocation(Irp)->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
 
    /* Do the request */
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        /* Wait for completion */
        KeWaitForSingleObject(&Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        Status = IoStatusBlock.Status;
    }
 
    /* Check if we couldn't get the data */
    if (!NT_SUCCESS(Status))
    {
        /* Check if caller wanted to know about the device and fail */
        if (DeviceError) *DeviceError = TRUE;
        return FALSE;
    }
 
    /* All went well */
    return TRUE;
}

Referenced by FsRecBtrfsFsControl(), FsRecExtFsControl(), FsRecFatxFsControl(), FsRecFfsFsControl(), FsRecIsCdfsVolume(), FsRecIsUdfsVolume(), FsRecNtfsFsControl(), FsRecReiserfsFsControl(), and FsRecVfatFsControl().