volinfo.c File Reference

#include "cdprocs.h"

Include dependency graph for volinfo.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (CDFS_BUG_CHECK_VOLINFO)

Functions
	_Requires_lock_held_ (_Global_critical_region_)
NTSTATUS	CdQueryFsSizeInfo (_In_ PIRP_CONTEXT IrpContext, _In_ PVCB Vcb, _Out_ PFILE_FS_SIZE_INFORMATION Buffer, _Inout_ PULONG Length)
NTSTATUS	CdQueryFsDeviceInfo (_In_ PIRP_CONTEXT IrpContext, _In_ PVCB Vcb, _Out_ PFILE_FS_DEVICE_INFORMATION Buffer, _Inout_ PULONG Length)
NTSTATUS	CdQueryFsAttributeInfo (_In_ PIRP_CONTEXT IrpContext, _In_ PVCB Vcb, _Out_ PFILE_FS_ATTRIBUTE_INFORMATION Buffer, _Inout_ PULONG Length)
NTSTATUS	CdQueryFsSectorSizeInfo (_In_ PIRP_CONTEXT IrpContext, _In_ PVCB Vcb, _Out_writes_bytes_(*Length) PFILE_FS_SECTOR_SIZE_INFORMATION Buffer, _Inout_ PULONG Length)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_VOLINFO)

Definition at line 23 of file volinfo.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 29 of file volinfo.c.

{
    NTSTATUS Status = STATUS_INVALID_PARAMETER;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    ULONG Length;
 
    TYPE_OF_OPEN TypeOfOpen;
    PFCB Fcb;
    PCCB Ccb;
 
    PAGED_CODE();
 
    //
    //  Reference our input parameters to make things easier
    //
 
    Length = IrpSp->Parameters.QueryVolume.Length;
 
    //
    //  Decode the file object and fail if this an unopened file object.
    //
 
    TypeOfOpen = CdDecodeFileObject( IrpContext, IrpSp->FileObject, &Fcb, &Ccb );
 
    if (TypeOfOpen == UnopenedFileObject) {
 
        CdCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    //  Acquire the Vcb for this volume.
    //
 
    CdAcquireVcbShared( IrpContext, Fcb->Vcb, FALSE );
 
    //
    //  Use a try-finally to facilitate cleanup.
    //
 
    _SEH2_TRY {
 
        //
        //  Verify the Vcb.
        //
 
        CdVerifyVcb( IrpContext, Fcb->Vcb );
 
        //
        //  Based on the information class we'll do different actions.  Each
        //  of the procedures that we're calling fills up the output buffer
        //  if possible and returns true if it successfully filled the buffer
        //  and false if it couldn't wait for any I/O to complete.
        //
 
#ifdef __REACTOS__
        RtlZeroMemory(Irp->AssociatedIrp.SystemBuffer, Length);
#endif // __REACTOS__
 
        switch (IrpSp->Parameters.QueryVolume.FsInformationClass) {
 
        case FileFsSizeInformation:
 
            Status = CdQueryFsSizeInfo( IrpContext, Fcb->Vcb, Irp->AssociatedIrp.SystemBuffer, &Length );
            break;
 
        case FileFsVolumeInformation:
 
            Status = CdQueryFsVolumeInfo( IrpContext, Fcb->Vcb, Irp->AssociatedIrp.SystemBuffer, &Length );
            break;
 
        case FileFsDeviceInformation:
 
            Status = CdQueryFsDeviceInfo( IrpContext, Fcb->Vcb, Irp->AssociatedIrp.SystemBuffer, &Length );
            break;
 
        case FileFsAttributeInformation:
 
            Status = CdQueryFsAttributeInfo( IrpContext, Fcb->Vcb, Irp->AssociatedIrp.SystemBuffer, &Length );
            break;
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
        case FileFsSectorSizeInformation:
 
            Status = CdQueryFsSectorSizeInfo( IrpContext, Fcb->Vcb, Irp->AssociatedIrp.SystemBuffer, &Length );
            break;
#endif
 
        /* ReactOS Change: GCC "enumeration value not handled in switch" */
        default: break;
        }
 
        //
        //  Set the information field to the number of bytes actually filled in
        //
 
        Irp->IoStatus.Information = IrpSp->Parameters.QueryVolume.Length - Length;
 
    } _SEH2_FINALLY {
 
        //
        //  Release the Vcb.
        //
 
        CdReleaseVcb( IrpContext, Fcb->Vcb );
    } _SEH2_END;
 
    //
    //  Complete the request if we didn't raise.
    //
 
    CdCompleteRequest( IrpContext, Irp, Status );
 
    return Status;
}

CdQueryFsAttributeInfo()

NTSTATUS CdQueryFsAttributeInfo	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PVCB	Vcb,
		_Out_ PFILE_FS_ATTRIBUTE_INFORMATION	Buffer,
		_Inout_ PULONG	Length
	)

Definition at line 450 of file volinfo.c.

{
    ULONG BytesToCopy;
 
    NTSTATUS Status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( Vcb );
 
    //
    //  Fill out the fixed portion of the buffer.
    //
 
    Buffer->FileSystemAttributes = FILE_CASE_SENSITIVE_SEARCH |
                                   FILE_READ_ONLY_VOLUME |
                                   FILE_SUPPORTS_OPEN_BY_FILE_ID;
 
    if (FlagOn( IrpContext->Vcb->VcbState, VCB_STATE_JOLIET )) {
 
        SetFlag( Buffer->FileSystemAttributes, FILE_UNICODE_ON_DISK );
 
        Buffer->MaximumComponentNameLength = 110;
 
    } else {
 
        Buffer->MaximumComponentNameLength = 221;
    }
 
    *Length -= FIELD_OFFSET( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName );
 
    //
    //  Make sure we can copy full unicode characters.
    //
 
    ClearFlag( *Length, 1 );
 
    //
    //  Determine how much of the file system name will fit.
    //
 
    if (*Length >= 8) {
 
        BytesToCopy = 8;
 
    } else {
 
        BytesToCopy = *Length;
        Status = STATUS_BUFFER_OVERFLOW;
    }
 
    *Length -= BytesToCopy;
 
    //
    //  Do the file system name.
    //
 
    Buffer->FileSystemNameLength = BytesToCopy;
 
    RtlCopyMemory( &Buffer->FileSystemName[0], L"CDFS", BytesToCopy );
 
    //
    //  And return to our caller
    //
 
    return Status;
}

CdQueryFsDeviceInfo()

NTSTATUS CdQueryFsDeviceInfo	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PVCB	Vcb,
		_Out_ PFILE_FS_DEVICE_INFORMATION	Buffer,
		_Inout_ PULONG	Length
	)

Definition at line 386 of file volinfo.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Update the output buffer.
    //
 
    Buffer->Characteristics = Vcb->TargetDeviceObject->Characteristics;
#ifndef __REACTOS__
    Buffer->DeviceType = FILE_DEVICE_CD_ROM;
#else
    Buffer->DeviceType = Vcb->TargetDeviceObject->DeviceType;
#endif
 
    //
    //  Adjust the length variable
    //
 
    *Length -= sizeof( FILE_FS_DEVICE_INFORMATION );
 
    //
    //  And return success to our caller
    //
 
    return STATUS_SUCCESS;
}

CdQueryFsSectorSizeInfo()

NTSTATUS CdQueryFsSectorSizeInfo	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PVCB	Vcb,
		_Out_writes_bytes_ *Length PFILE_FS_SECTOR_SIZE_INFORMATION	Buffer,
		_Inout_ PULONG	Length
	)

Definition at line 549 of file volinfo.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Sufficient buffer size is guaranteed by the I/O manager or the
    //  originating kernel mode driver.
    //
 
    ASSERT( *Length >= sizeof( FILE_FS_SECTOR_SIZE_INFORMATION ));
    _Analysis_assume_( *Length >= sizeof( FILE_FS_SECTOR_SIZE_INFORMATION ));
 
    //
    //  Retrieve the sector size information
    //
 
    Status = FsRtlGetSectorSizeInformation( Vcb->Vpb->RealDevice,
                                            Buffer );
 
    //
    //  Adjust the length variable
    //
 
    if (NT_SUCCESS( Status )) {
 
        *Length -= sizeof( FILE_FS_SECTOR_SIZE_INFORMATION );
    }
 
    return Status;
}

CdQueryFsSizeInfo()

NTSTATUS CdQueryFsSizeInfo	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PVCB	Vcb,
		_Out_ PFILE_FS_SIZE_INFORMATION	Buffer,
		_Inout_ PULONG	Length
	)

Definition at line 323 of file volinfo.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Fill in the output buffer.
    //
 
    Buffer->TotalAllocationUnits.QuadPart = LlSectorsFromBytes( Vcb->VolumeDasdFcb->AllocationSize.QuadPart );
 
    Buffer->AvailableAllocationUnits.QuadPart = 0;
    Buffer->SectorsPerAllocationUnit = 1;
    Buffer->BytesPerSector = SECTOR_SIZE;
 
    //
    //  Adjust the length variable
    //
 
    *Length -= sizeof( FILE_FS_SIZE_INFORMATION );
 
    //
    //  And return success to our caller
    //
 
    return STATUS_SUCCESS;
}