Volume.c File Reference

#include "fltmgr.h"
#include "fltmgrint.h"
#include <debug.h>

Include dependency graph for Volume.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
NTSTATUS FLTAPI	FltGetVolumeProperties (_In_ PFLT_VOLUME Volume, _Out_writes_bytes_to_opt_(VolumePropertiesLength, *LengthReturned) PFLT_VOLUME_PROPERTIES VolumeProperties, _In_ ULONG VolumePropertiesLength, _Out_ PULONG LengthReturned)
NTSTATUS FLTAPI	FltEnumerateVolumes (_In_ PFLT_FILTER Filter, _Out_writes_to_opt_(VolumeListSize, *NumberVolumesReturned) PFLT_VOLUME *VolumeList, _In_ ULONG VolumeListSize, _Out_ PULONG NumberVolumesReturned)
NTSTATUS FLTAPI	FltDetachVolume (_Inout_ PFLT_FILTER Filter, _Inout_ PFLT_VOLUME Volume, _In_opt_ PCUNICODE_STRING InstanceName)
NTSTATUS FLTAPI	FltAttachVolume (_Inout_ PFLT_FILTER Filter, _Inout_ PFLT_VOLUME Volume, _In_opt_ PCUNICODE_STRING InstanceName, _Outptr_opt_result_maybenull_ PFLT_INSTANCE *RetInstance)
NTSTATUS FLTAPI	FltGetVolumeName (_In_ PFLT_VOLUME Volume, _Inout_opt_ PUNICODE_STRING VolumeName, _Out_opt_ PULONG BufferSizeNeeded)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file Volume.c.

Function Documentation

FltAttachVolume()

NTSTATUS FLTAPI FltAttachVolume	(	_Inout_ PFLT_FILTER	Filter,
		_Inout_ PFLT_VOLUME	Volume,
		_In_opt_ PCUNICODE_STRING	InstanceName,
		_Outptr_opt_result_maybenull_ PFLT_INSTANCE *	RetInstance
	)

Definition at line 195 of file Volume.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

FltDetachVolume()

NTSTATUS FLTAPI FltDetachVolume	(	_Inout_ PFLT_FILTER	Filter,
		_Inout_ PFLT_VOLUME	Volume,
		_In_opt_ PCUNICODE_STRING	InstanceName
	)

Definition at line 184 of file Volume.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

FltEnumerateVolumes()

NTSTATUS FLTAPI FltEnumerateVolumes	(	_In_ PFLT_FILTER	Filter,
		_Out_writes_to_opt_(VolumeListSize, *NumberVolumesReturned) PFLT_VOLUME *	VolumeList,
		_In_ ULONG	VolumeListSize,
		_Out_ PULONG	NumberVolumesReturned
	)

Definition at line 112 of file Volume.c.

{
    ULONG i;
    PFLTP_FRAME Frame;
    PFLT_VOLUME Volume;
    PLIST_ENTRY ListEntry;
    ULONG NumberOfVolumes = 0;
    NTSTATUS Status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    Frame = Filter->Frame;
 
    /* Lock the attached volumes list */
    KeEnterCriticalRegion();
    ExAcquireResourceSharedLite(&Frame->AttachedVolumes.rLock, TRUE);
 
    /* If it's not empty */
    if (!IsListEmpty(&Frame->AttachedVolumes.rList))
    {
        /* Browse every entry */
        for (ListEntry = Frame->AttachedVolumes.rList.Flink;
             ListEntry != &Frame->AttachedVolumes.rList;
             ListEntry = ListEntry->Flink)
        {
            /* Get the volume */
            Volume = CONTAINING_RECORD(ListEntry, FLT_VOLUME, Base.PrimaryLink);
 
            /* If there's still room in the output buffer */
            if (NumberOfVolumes < VolumeListSize)
            {
                /* Reference the volume and return it */
                FltObjectReference(Volume);
                VolumeList[NumberOfVolumes] = Volume;
            }
 
            /* We returned one more volume */
            ++NumberOfVolumes;
        }
    }
 
    /* Release the list */
    ExReleaseResourceLite(&Frame->AttachedVolumes.rLock);
    KeLeaveCriticalRegion();
 
    /* If we want to return more volumes than we can */
    if (NumberOfVolumes > VolumeListSize)
    {
        /* We will clear output */
        for (i = 0; i < VolumeListSize; ++i)
        {
            FltObjectDereference(VolumeList[i]);
            VolumeList[i] = NULL;
        }
 
        /* And set failure status */
        Status = STATUS_BUFFER_TOO_SMALL;
    }
 
    /* Always return the max amount of volumes we want to return */
    *NumberVolumesReturned = NumberOfVolumes;
 
    /* Done */
    return Status;
}

FltGetVolumeName()

NTSTATUS FLTAPI FltGetVolumeName	(	_In_ PFLT_VOLUME	Volume,
		_Inout_opt_ PUNICODE_STRING	VolumeName,
		_Out_opt_ PULONG	BufferSizeNeeded
	)

Definition at line 207 of file Volume.c.

{
    NTSTATUS Status;
 
    /* Check if caller just probes for size */
    if (VolumeName == NULL)
    {
        /* Totally broken call */
        if (BufferSizeNeeded == NULL)
        {
            return STATUS_INVALID_PARAMETER;
        }
 
        /* Return the appropriate size and quit */
        *BufferSizeNeeded = Volume->DeviceName.Length;
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    /* We have an output buffer! Assume it's too small */
    Status = STATUS_BUFFER_TOO_SMALL;
 
    /* If we have output size, fill it */
    if (BufferSizeNeeded != NULL)
    {
        *BufferSizeNeeded = Volume->DeviceName.Length;
    }
 
    /* Init that we didn't return a thing */
    VolumeName->Length = 0;
 
    /* If we have enough room, copy and return success */
    if (VolumeName->MaximumLength >= Volume->DeviceName.Length)
    {
        RtlCopyUnicodeString(VolumeName, &Volume->DeviceName);
        Status = STATUS_SUCCESS;
    }
 
    return Status;
}

FltGetVolumeProperties()

NTSTATUS FLTAPI FltGetVolumeProperties	(	_In_ PFLT_VOLUME	Volume,
		_Out_writes_bytes_to_opt_(VolumePropertiesLength, *LengthReturned) PFLT_VOLUME_PROPERTIES	VolumeProperties,
		_In_ ULONG	VolumePropertiesLength,
		_Out_ PULONG	LengthReturned
	)

Definition at line 26 of file Volume.c.

{
    ULONG BufferRequired;
    ULONG BytesWritten;
    PCHAR Ptr;
    NTSTATUS Status;
 
    /* Calculate the required buffer size */
    BufferRequired = sizeof(FLT_VOLUME_PROPERTIES) +
                     Volume->CDODriverName.Length +
                     Volume->DeviceName.Length +
                     Volume->CDODeviceName.Length;
 
    /* If we don't have enough buffer to fill in the fixed struct, return with the required size */
    if (VolumePropertiesLength < sizeof(FLT_VOLUME_PROPERTIES))
    {
        *LengthReturned = BufferRequired;
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    /* Clear out the buffer */
    RtlZeroMemory(VolumeProperties, sizeof(FLT_VOLUME_PROPERTIES));
 
    /* Fill in the fixed data */
    VolumeProperties->DeviceType = Volume->DeviceObject->DeviceType;
    VolumeProperties->DeviceObjectFlags = Volume->DeviceObject->Flags;
    VolumeProperties->AlignmentRequirement = Volume->DeviceObject->AlignmentRequirement;
    VolumeProperties->SectorSize = Volume->DeviceObject->SectorSize;
    if (Volume->DiskDeviceObject)
    {
        VolumeProperties->DeviceCharacteristics = Volume->DiskDeviceObject->Characteristics;
    }
    else
    {
        VolumeProperties->DeviceCharacteristics = Volume->DeviceObject->Characteristics;
    }
 
    /* So far we've written the fixed struct data */
    BytesWritten = sizeof(FLT_VOLUME_PROPERTIES);
    Ptr = (PCHAR)(VolumeProperties + 1);
 
    /* Make sure we have enough room to add the dynamic data */
    if (VolumePropertiesLength >= BufferRequired)
    {
        /* Add the FS device name */
        VolumeProperties->FileSystemDeviceName.Length = 0;
        VolumeProperties->FileSystemDeviceName.MaximumLength = Volume->CDODeviceName.Length;
        VolumeProperties->FileSystemDeviceName.Buffer = (PWCH)Ptr;
        RtlCopyUnicodeString(&VolumeProperties->FileSystemDeviceName, &Volume->CDODeviceName);
        Ptr += VolumeProperties->FileSystemDeviceName.Length;
 
        /* Add the driver name */
        VolumeProperties->FileSystemDriverName.Length = 0;
        VolumeProperties->FileSystemDriverName.MaximumLength = Volume->CDODriverName.Length;
        VolumeProperties->FileSystemDriverName.Buffer = (PWCH)Ptr;
        RtlCopyUnicodeString(&VolumeProperties->FileSystemDriverName, &Volume->CDODriverName);
        Ptr += VolumeProperties->FileSystemDriverName.Length;
 
        /* Add the volume name */
        VolumeProperties->RealDeviceName.Length = 0;
        VolumeProperties->RealDeviceName.MaximumLength = Volume->DeviceName.Length;
        VolumeProperties->RealDeviceName.Buffer = (PWCH)Ptr;
        RtlCopyUnicodeString(&VolumeProperties->RealDeviceName, &Volume->DeviceName);
 
        BytesWritten = BufferRequired;
 
        Status = STATUS_SUCCESS;
    }
    else
    {
        Status = STATUS_BUFFER_OVERFLOW;
    }
 
    /* Set the number of bytes we wrote and return */
    *LengthReturned = BytesWritten;
    return Status;
}

Referenced by FilterInstanceSetup().