volinfo.c File Reference

#include "ntfs.h"
#include <debug.h>

Include dependency graph for volinfo.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
NtfsLoadVolumeBitmap
Reads $Bitmap into memory once at mount. Cluster allocation and freeing work on this copy and write back only the sectors they change. Parameters DeviceExt Volume being mounted. Its file record lookaside list and MFT context must be ready. Returns STATUS_SUCCESS, or an error if $Bitmap could not be found or read.
NTSTATUS	NtfsLoadVolumeBitmap (_In_ PDEVICE_EXTENSION DeviceExt)
NtfsFreeVolumeBitmap
Releases what NtfsLoadVolumeBitmap() set up. Safe on a partly loaded volume. Parameters DeviceExt Volume whose bitmap copy is released.
VOID	NtfsFreeVolumeBitmap (_In_ PDEVICE_EXTENSION DeviceExt)
NtfsWriteVolumeBitmap
Writes the sectors of $Bitmap that hold the given clusters' bits. The caller holds BitmapResource exclusively. Parameters DeviceExt Volume whose bitmap changed. FirstCluster First cluster whose bit changed. ClusterCount Number of clusters, starting at FirstCluster, to cover. Can't be 0. Returns Status from WriteAttribute().
NTSTATUS	NtfsWriteVolumeBitmap (_In_ PDEVICE_EXTENSION DeviceExt, _In_ ULONG FirstCluster, _In_ ULONG ClusterCount)
ULONGLONG	NtfsGetFreeClusters (PDEVICE_EXTENSION DeviceExt)
NTSTATUS	NtfsAllocateClusters (PDEVICE_EXTENSION DeviceExt, ULONG FirstDesiredCluster, ULONG DesiredClusters, PULONG FirstAssignedCluster, PULONG AssignedClusters)
static NTSTATUS	NtfsGetFsVolumeInformation (PDEVICE_OBJECT DeviceObject, PFILE_FS_VOLUME_INFORMATION FsVolumeInfo, PULONG BufferLength)
static NTSTATUS	NtfsGetFsAttributeInformation (PDEVICE_EXTENSION DeviceExt, PFILE_FS_ATTRIBUTE_INFORMATION FsAttributeInfo, PULONG BufferLength)
static NTSTATUS	NtfsGetFsSizeInformation (PDEVICE_OBJECT DeviceObject, PFILE_FS_SIZE_INFORMATION FsSizeInfo, PULONG BufferLength)
static NTSTATUS	NtfsGetFsDeviceInformation (PDEVICE_OBJECT DeviceObject, PFILE_FS_DEVICE_INFORMATION FsDeviceInfo, PULONG BufferLength)
NTSTATUS	NtfsQueryVolumeInformation (PNTFS_IRP_CONTEXT IrpContext)
NTSTATUS	NtfsSetVolumeInformation (PNTFS_IRP_CONTEXT IrpContext)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 31 of file volinfo.c.

Function Documentation

NtfsAllocateClusters()

NTSTATUS NtfsAllocateClusters	(	PDEVICE_EXTENSION	DeviceExt,
		ULONG	FirstDesiredCluster,
		ULONG	DesiredClusters,
		PULONG	FirstAssignedCluster,
		PULONG	AssignedClusters
	)

NtfsAllocateClusters Allocates a run of clusters. The run allocated might be smaller than DesiredClusters.

Definition at line 213 of file volinfo.c.

{
    NTSTATUS Status;
    PRTL_BITMAP Bitmap = &DeviceExt->ClusterBitmap;
    ULONG AssignedRun;
 
    DPRINT("NtfsAllocateClusters(%p, %lu, %lu, %p, %p)\n", DeviceExt, FirstDesiredCluster, DesiredClusters, FirstAssignedCluster, AssignedClusters);
 
    *AssignedClusters = 0;
 
    /* Files growing in parallel must not both claim the same free run */
    KeEnterCriticalRegion();
    ExAcquireResourceExclusiveLite(&DeviceExt->BitmapResource, TRUE);
 
    if (DeviceExt->FreeClusterCount < DesiredClusters)
    {
        Status = STATUS_DISK_FULL;
        goto Quit;
    }
 
    /* The hint is just past the file's last cluster, which can be past the volume end */
    if (FirstDesiredCluster >= Bitmap->SizeOfBitMap)
        FirstDesiredCluster = 0;
 
    // TODO: Observe MFT reservation zone
 
    // Can we get one contiguous run?
    AssignedRun = RtlFindClearBitsAndSet(Bitmap, DesiredClusters, FirstDesiredCluster);
 
    if (AssignedRun != 0xFFFFFFFF)
    {
        *FirstAssignedCluster = AssignedRun;
        *AssignedClusters = DesiredClusters;
    }
    else
    {
        // we can't get one contiguous run
        *AssignedClusters = RtlFindNextForwardRunClear(Bitmap, FirstDesiredCluster, FirstAssignedCluster);
 
        if (*AssignedClusters == 0)
        {
            // we couldn't find any runs starting at DesiredFirstCluster
            *AssignedClusters = RtlFindLongestRunClear(Bitmap, FirstAssignedCluster);
        }
 
        if (*AssignedClusters == 0)
        {
            Status = STATUS_DISK_FULL;
            goto Quit;
        }
 
        /* Hand out no more than was asked for, and mark it in use */
        *AssignedClusters = min(*AssignedClusters, DesiredClusters);
        RtlSetBits(Bitmap, *FirstAssignedCluster, *AssignedClusters);
    }
 
    Status = NtfsWriteVolumeBitmap(DeviceExt, *FirstAssignedCluster, *AssignedClusters);
    if (NT_SUCCESS(Status))
    {
        DeviceExt->FreeClusterCount -= *AssignedClusters;
    }
    else
    {
        /* Keep the copy in step with what the disk says */
        RtlClearBits(Bitmap, *FirstAssignedCluster, *AssignedClusters);
        *AssignedClusters = 0;
    }
 
Quit:
    ExReleaseResourceLite(&DeviceExt->BitmapResource);
    KeLeaveCriticalRegion();
 
    return Status;
}

Referenced by NtfsExtendAllocation().

NtfsFreeVolumeBitmap()

VOID NtfsFreeVolumeBitmap

(

_In_ PDEVICE_EXTENSION

DeviceExt

)

Definition at line 132 of file volinfo.c.

{
    if (DeviceExt->BitmapBuffer != NULL)
    {
        ExFreePoolWithTag(DeviceExt->BitmapBuffer, TAG_NTFS);
        DeviceExt->BitmapBuffer = NULL;
    }
 
    if (DeviceExt->BitmapContext != NULL)
    {
        ReleaseAttributeContext(DeviceExt->BitmapContext);
        DeviceExt->BitmapContext = NULL;
    }
}

Referenced by NtfsLoadVolumeBitmap().

NtfsGetFreeClusters()

ULONGLONG NtfsGetFreeClusters

(

PDEVICE_EXTENSION

DeviceExt

)

Definition at line 193 of file volinfo.c.

{
    ULONGLONG FreeClusters;
 
    DPRINT("NtfsGetFreeClusters(%p)\n", DeviceExt);
 
    KeEnterCriticalRegion();
    ExAcquireResourceSharedLite(&DeviceExt->BitmapResource, TRUE);
    FreeClusters = DeviceExt->FreeClusterCount;
    ExReleaseResourceLite(&DeviceExt->BitmapResource);
    KeLeaveCriticalRegion();
 
    return FreeClusters;
}

Referenced by GetNfsVolumeData(), and NtfsGetFsSizeInformation().

NtfsGetFsAttributeInformation()

static NTSTATUS NtfsGetFsAttributeInformation ( PDEVICE_EXTENSION  DeviceExt, PFILE_FS_ATTRIBUTE_INFORMATION  FsAttributeInfo, PULONG  BufferLength  )

static

Definition at line 340 of file volinfo.c.

{
    UNREFERENCED_PARAMETER(DeviceExt);
 
    DPRINT("NtfsGetFsAttributeInformation()\n");
    DPRINT("FsAttributeInfo = %p\n", FsAttributeInfo);
    DPRINT("BufferLength %lu\n", *BufferLength);
    DPRINT("Required length %lu\n", (sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 8));
 
    if (*BufferLength < sizeof (FILE_FS_ATTRIBUTE_INFORMATION))
        return STATUS_INFO_LENGTH_MISMATCH;
 
    if (*BufferLength < (sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 8))
        return STATUS_BUFFER_OVERFLOW;
 
    FsAttributeInfo->FileSystemAttributes =
        FILE_CASE_PRESERVED_NAMES | FILE_UNICODE_ON_DISK | FILE_READ_ONLY_VOLUME;
    FsAttributeInfo->MaximumComponentNameLength = 255;
    FsAttributeInfo->FileSystemNameLength = 8;
 
    memcpy(FsAttributeInfo->FileSystemName, L"NTFS", 8);
 
    DPRINT("Finished NtfsGetFsAttributeInformation()\n");
 
    *BufferLength -= (sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 8);
    DPRINT("BufferLength %lu\n", *BufferLength);
 
    return STATUS_SUCCESS;
}

Referenced by NtfsQueryVolumeInformation().

NtfsGetFsDeviceInformation()

static NTSTATUS NtfsGetFsDeviceInformation ( PDEVICE_OBJECT  DeviceObject, PFILE_FS_DEVICE_INFORMATION  FsDeviceInfo, PULONG  BufferLength  )

static

Definition at line 405 of file volinfo.c.

{
    DPRINT("NtfsGetFsDeviceInformation()\n");
    DPRINT("FsDeviceInfo = %p\n", FsDeviceInfo);
    DPRINT("BufferLength %lu\n", *BufferLength);
    DPRINT("Required length %lu\n", sizeof(FILE_FS_DEVICE_INFORMATION));
 
    if (*BufferLength < sizeof(FILE_FS_DEVICE_INFORMATION))
        return STATUS_BUFFER_OVERFLOW;
 
    FsDeviceInfo->DeviceType = FILE_DEVICE_DISK;
    FsDeviceInfo->Characteristics = DeviceObject->Characteristics;
 
    DPRINT("NtfsGetFsDeviceInformation() finished.\n");
 
    *BufferLength -= sizeof(FILE_FS_DEVICE_INFORMATION);
    DPRINT("BufferLength %lu\n", *BufferLength);
 
    return STATUS_SUCCESS;
}

Referenced by NtfsQueryVolumeInformation().

NtfsGetFsSizeInformation()

static NTSTATUS NtfsGetFsSizeInformation ( PDEVICE_OBJECT  DeviceObject, PFILE_FS_SIZE_INFORMATION  FsSizeInfo, PULONG  BufferLength  )

static

Definition at line 375 of file volinfo.c.

{
    PDEVICE_EXTENSION DeviceExt;
    NTSTATUS Status = STATUS_SUCCESS;
 
    DPRINT("NtfsGetFsSizeInformation()\n");
    DPRINT("FsSizeInfo = %p\n", FsSizeInfo);
 
    if (*BufferLength < sizeof(FILE_FS_SIZE_INFORMATION))
        return STATUS_BUFFER_OVERFLOW;
 
    DeviceExt = DeviceObject->DeviceExtension;
 
    FsSizeInfo->AvailableAllocationUnits.QuadPart = NtfsGetFreeClusters(DeviceExt);
    FsSizeInfo->TotalAllocationUnits.QuadPart = DeviceExt->NtfsInfo.ClusterCount;
    FsSizeInfo->SectorsPerAllocationUnit = DeviceExt->NtfsInfo.SectorsPerCluster;
    FsSizeInfo->BytesPerSector = DeviceExt->NtfsInfo.BytesPerSector;
 
    DPRINT("Finished NtfsGetFsSizeInformation()\n");
    if (NT_SUCCESS(Status))
        *BufferLength -= sizeof(FILE_FS_SIZE_INFORMATION);
 
    return Status;
}

Referenced by NtfsQueryVolumeInformation().

NtfsGetFsVolumeInformation()

static NTSTATUS NtfsGetFsVolumeInformation ( PDEVICE_OBJECT  DeviceObject, PFILE_FS_VOLUME_INFORMATION  FsVolumeInfo, PULONG  BufferLength  )

static

Definition at line 294 of file volinfo.c.

{
    DPRINT("NtfsGetFsVolumeInformation() called\n");
    DPRINT("FsVolumeInfo = %p\n", FsVolumeInfo);
    DPRINT("BufferLength %lu\n", *BufferLength);
 
    DPRINT("Vpb %p\n", DeviceObject->Vpb);
 
    DPRINT("Required length %lu\n",
           sizeof(FILE_FS_VOLUME_INFORMATION) + DeviceObject->Vpb->VolumeLabelLength);
    DPRINT("LabelLength %hu\n",
           DeviceObject->Vpb->VolumeLabelLength);
    DPRINT("Label %.*S\n",
           DeviceObject->Vpb->VolumeLabelLength / sizeof(WCHAR),
           DeviceObject->Vpb->VolumeLabel);
 
    if (*BufferLength < sizeof(FILE_FS_VOLUME_INFORMATION))
        return STATUS_INFO_LENGTH_MISMATCH;
 
    if (*BufferLength < (sizeof(FILE_FS_VOLUME_INFORMATION) + DeviceObject->Vpb->VolumeLabelLength))
        return STATUS_BUFFER_OVERFLOW;
 
    /* valid entries */
    FsVolumeInfo->VolumeSerialNumber = DeviceObject->Vpb->SerialNumber;
    FsVolumeInfo->VolumeLabelLength = DeviceObject->Vpb->VolumeLabelLength;
    memcpy(FsVolumeInfo->VolumeLabel,
           DeviceObject->Vpb->VolumeLabel,
           DeviceObject->Vpb->VolumeLabelLength);
 
    /* dummy entries */
    FsVolumeInfo->VolumeCreationTime.QuadPart = 0;
    FsVolumeInfo->SupportsObjects = FALSE;
 
    *BufferLength -= (sizeof(FILE_FS_VOLUME_INFORMATION) + DeviceObject->Vpb->VolumeLabelLength);
 
    DPRINT("BufferLength %lu\n", *BufferLength);
    DPRINT("NtfsGetFsVolumeInformation() done\n");
 
    return STATUS_SUCCESS;
}

Referenced by NtfsQueryVolumeInformation().

NtfsLoadVolumeBitmap()

NTSTATUS NtfsLoadVolumeBitmap

(

_In_ PDEVICE_EXTENSION

DeviceExt

)

Definition at line 49 of file volinfo.c.

{
    PFILE_RECORD_HEADER BitmapRecord;
    ULONGLONG BitmapSize;
    ULONG BufferSize;
    NTSTATUS Status;
 
    BitmapRecord = ExAllocateFromNPagedLookasideList(&DeviceExt->FileRecLookasideList);
    if (BitmapRecord == NULL)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    Status = ReadFileRecord(DeviceExt, NTFS_FILE_BITMAP, BitmapRecord);
    if (NT_SUCCESS(Status))
    {
        /* The context keeps its own copy of the attribute record */
        Status = FindAttribute(DeviceExt, BitmapRecord, AttributeData, L"", 0, &DeviceExt->BitmapContext, NULL);
    }
 
    ExFreeToNPagedLookasideList(&DeviceExt->FileRecLookasideList, BitmapRecord);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Unable to find $Bitmap (Status %lx)\n", Status);
        DeviceExt->BitmapContext = NULL;
        return Status;
    }
 
    BitmapSize = AttributeDataLength(DeviceExt->BitmapContext->pRecord);
    if (BitmapSize > MAXULONG ||
        BitmapSize * 8 < DeviceExt->NtfsInfo.ClusterCount ||
        DeviceExt->NtfsInfo.ClusterCount > MAXULONG)
    {
        DPRINT1("$Bitmap size %I64u does not cover %I64u clusters\n",
                BitmapSize, DeviceExt->NtfsInfo.ClusterCount);
        Status = STATUS_FILE_CORRUPT_ERROR;
        goto Fail;
    }
 
    /* Whole sectors, so write back never reads first */
    BufferSize = ROUND_UP((ULONG)BitmapSize, DeviceExt->NtfsInfo.BytesPerSector);
    DeviceExt->BitmapBuffer = ExAllocatePoolWithTag(PagedPool, BufferSize, TAG_NTFS);
    if (DeviceExt->BitmapBuffer == NULL)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Fail;
    }
    RtlZeroMemory(DeviceExt->BitmapBuffer, BufferSize);
 
    if (ReadAttribute(DeviceExt, DeviceExt->BitmapContext, 0, (PCHAR)DeviceExt->BitmapBuffer, (ULONG)BitmapSize) != (ULONG)BitmapSize)
    {
        DPRINT1("Unable to read $Bitmap\n");
        Status = STATUS_UNSUCCESSFUL;
        goto Fail;
    }
 
    DeviceExt->BitmapSize = (ULONG)BitmapSize;
 
    /* $Bitmap is rounded up to a cluster and covers a few clusters more than
     * the volume has. Bounding by ClusterCount ignores the surplus bits, but
     * write back still preserves them on disk. */
    RtlInitializeBitMap(&DeviceExt->ClusterBitmap, DeviceExt->BitmapBuffer, (ULONG)DeviceExt->NtfsInfo.ClusterCount);
    DeviceExt->FreeClusterCount = RtlNumberOfClearBits(&DeviceExt->ClusterBitmap);
 
    DPRINT("Volume bitmap loaded: %I64u of %I64u clusters free\n",
           DeviceExt->FreeClusterCount, DeviceExt->NtfsInfo.ClusterCount);
 
    return STATUS_SUCCESS;
 
Fail:
    NtfsFreeVolumeBitmap(DeviceExt);
    return Status;
}

NtfsQueryVolumeInformation()

NTSTATUS NtfsQueryVolumeInformation

(

PNTFS_IRP_CONTEXT

IrpContext

)

Definition at line 430 of file volinfo.c.

{
    PIRP Irp;
    PDEVICE_OBJECT DeviceObject;
    FS_INFORMATION_CLASS FsInformationClass;
    PIO_STACK_LOCATION Stack;
    NTSTATUS Status = STATUS_SUCCESS;
    PVOID SystemBuffer;
    ULONG BufferLength;
    PDEVICE_EXTENSION DeviceExt;
 
    DPRINT("NtfsQueryVolumeInformation() called\n");
 
    ASSERT(IrpContext);
 
    Irp = IrpContext->Irp;
    DeviceObject = IrpContext->DeviceObject;
    DeviceExt = DeviceObject->DeviceExtension;
    Stack = IrpContext->Stack;
 
    if (!ExAcquireResourceSharedLite(&DeviceExt->DirResource,
                                     BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT)))
    {
        return NtfsMarkIrpContextForQueue(IrpContext);
    }
 
    FsInformationClass = Stack->Parameters.QueryVolume.FsInformationClass;
    BufferLength = Stack->Parameters.QueryVolume.Length;
    SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
    RtlZeroMemory(SystemBuffer, BufferLength);
 
    DPRINT("FsInformationClass %d\n", FsInformationClass);
    DPRINT("SystemBuffer %p\n", SystemBuffer);
 
    switch (FsInformationClass)
    {
        case FileFsVolumeInformation:
            Status = NtfsGetFsVolumeInformation(DeviceObject,
                                                SystemBuffer,
                                                &BufferLength);
            break;
 
        case FileFsAttributeInformation:
            Status = NtfsGetFsAttributeInformation(DeviceObject->DeviceExtension,
                                                   SystemBuffer,
                                                   &BufferLength);
            break;
 
        case FileFsSizeInformation:
            Status = NtfsGetFsSizeInformation(DeviceObject,
                                              SystemBuffer,
                                              &BufferLength);
            break;
 
        case FileFsDeviceInformation:
            Status = NtfsGetFsDeviceInformation(DeviceObject,
                                                SystemBuffer,
                                                &BufferLength);
            break;
 
        default:
            Status = STATUS_NOT_SUPPORTED;
    }
 
    ExReleaseResourceLite(&DeviceExt->DirResource);
 
    if (NT_SUCCESS(Status))
        Irp->IoStatus.Information =
            Stack->Parameters.QueryVolume.Length - BufferLength;
    else
        Irp->IoStatus.Information = 0;
 
    return Status;
}

Referenced by NtfsDispatch().

NtfsSetVolumeInformation()

NTSTATUS NtfsSetVolumeInformation

(

PNTFS_IRP_CONTEXT

IrpContext

)

Definition at line 507 of file volinfo.c.

{
    PIRP Irp;
 
    DPRINT("NtfsSetVolumeInformation() called\n");
 
    ASSERT(IrpContext);
 
    Irp = IrpContext->Irp;
    Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
    Irp->IoStatus.Information = 0;
 
    return STATUS_NOT_SUPPORTED;
}

Referenced by NtfsDispatch().

NtfsWriteVolumeBitmap()

NTSTATUS NtfsWriteVolumeBitmap	(	_In_ PDEVICE_EXTENSION	DeviceExt,
		_In_ ULONG	FirstCluster,
		_In_ ULONG	ClusterCount
	)

Definition at line 167 of file volinfo.c.

{
    ULONG SectorSize = DeviceExt->NtfsInfo.BytesPerSector;
    ULONG Start;
    ULONG End;
    ULONG LengthWritten;
 
    ASSERT(ClusterCount != 0);
 
    Start = ROUND_DOWN(FirstCluster / 8, SectorSize);
    End = ROUND_UP((FirstCluster + ClusterCount - 1) / 8 + 1, SectorSize);
    End = min(End, ROUND_UP(DeviceExt->BitmapSize, SectorSize));
 
    return WriteAttribute(DeviceExt,
                          DeviceExt->BitmapContext,
                          Start,
                          (PUCHAR)DeviceExt->BitmapBuffer + Start,
                          End - Start,
                          &LengthWritten,
                          NULL);
}

Referenced by FreeClusters(), and NtfsAllocateClusters().