fsctrl.c File Reference

#include "cdprocs.h"

Include dependency graph for fsctrl.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (CDFS_BUG_CHECK_FSCTRL)

Functions
	_Requires_lock_held_ (_Global_critical_region_)
NTSTATUS	CdUnlockVolumeInternal (_In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb, _In_opt_ PFILE_OBJECT FileObject)
VOID	CdReMountOldVcb (_In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB OldVcb, _Inout_ PVCB NewVcb, _In_ PDEVICE_OBJECT DeviceObjectWeTalkTo)
NTSTATUS	CdIsVolumeDirty (_Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
NTSTATUS	CdIsVolumeMounted (_Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
NTSTATUS	CdIsPathnameValid (_Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
NTSTATUS	CdAllowExtendedDasdIo (_Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
	_Success_ (return !=FALSE)
VOID	CdFindActiveVolDescriptor (_In_ PIRP_CONTEXT IrpContext, _In_ PVCB Vcb, _Inout_updates_bytes_(ROUND_TO_PAGES(SECTOR_SIZE)) PCHAR RawIsoVd, _In_ BOOLEAN VerifyVolume)

Variables
BOOLEAN	CdDisable = FALSE
BOOLEAN	CdNoJoliet = FALSE

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_FSCTRL)

Definition at line 23 of file fsctrl.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 36 of file fsctrl.c.

{
    NTSTATUS Status;
    KIRQL SavedIrql;
    NTSTATUS FinalStatus = (FileObject? STATUS_ACCESS_DENIED: STATUS_DEVICE_BUSY);
    ULONG RemainingUserReferences = (FileObject? 1: 0);
 
    //
    //  The cleanup count for the volume only reflects the fileobject that
    //  will lock the volume.  Otherwise, we must fail the request.
    //
    //  Since the only cleanup is for the provided fileobject, we will try
    //  to get rid of all of the other user references.  If there is only one
    //  remaining after the purge then we can allow the volume to be locked.
    //
 
    CdPurgeVolume( IrpContext, Vcb, FALSE );
 
    //
    //  Now back out of our synchronization and wait for the lazy writer
    //  to finish off any lazy closes that could have been outstanding.
    //
    //  Since we purged, we know that the lazy writer will issue all
    //  possible lazy closes in the next tick - if we hadn't, an otherwise
    //  unopened file with a large amount of dirty data could have hung
    //  around for a while as the data trickled out to the disk.
    //
    //  This is even more important now since we send notification to
    //  alert other folks that this style of check is about to happen so
    //  that they can close their handles.  We don't want to enter a fast
    //  race with the lazy writer tearing down his references to the file.
    //
 
    CdReleaseVcb( IrpContext, Vcb );
 
    Status = CcWaitForCurrentLazyWriterActivity();
 
    //
    //  This is intentional. If we were able to get the Vcb before, just
    //  wait for it and take advantage of knowing that it is OK to leave
    //  the flag up.
    //
 
    SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
    CdAcquireVcbExclusive( IrpContext, Vcb, FALSE );
 
    if (!NT_SUCCESS( Status )) {
 
        return Status;
    }
 
    CdFspClose( Vcb );
 
    //
    //  If the volume is already explicitly locked then fail.  We use the
    //  Vpb locked flag as an 'explicit lock' flag in the same way as Fat.
    //
 
    IoAcquireVpbSpinLock( &SavedIrql );
 
    if (!FlagOn( Vcb->Vpb->Flags, VPB_LOCKED ) &&
        (Vcb->VcbCleanup == RemainingUserReferences) &&
        (Vcb->VcbUserReference == CDFS_RESIDUAL_USER_REFERENCE + RemainingUserReferences))  {
 
        SetFlag( Vcb->VcbState, VCB_STATE_LOCKED );
        SetFlag( Vcb->Vpb->Flags, VPB_LOCKED);
        Vcb->VolumeLockFileObject = FileObject;
        FinalStatus = STATUS_SUCCESS;
    }
 
    IoReleaseVpbSpinLock( SavedIrql );
 
    return FinalStatus;
}

_Success_()

_Success_

(

return !

= FALSE

)

Definition at line 2825 of file fsctrl.c.

{
    NTSTATUS Status;
    ULONG ThisPass = 1;
    BOOLEAN FoundVd = FALSE;
 
    ULONG BaseSector;
    ULONG SectorOffset;
 
    PCDROM_TOC_LARGE CdromToc;
 
    ULONG VolumeFlags;
 
    PAGED_CODE();
 
    //
    //  If there are no data tracks, don't even bother hunting for descriptors.
    //
    //  This explicitly breaks various non-BlueBook compliant CDs that scribble
    //  an ISO filesystem on media claiming only audio tracks.  Since these
    //  disks can cause serious problems in some CDROM units, fail fast.  I admit
    //  that it is possible that someone can still record the descriptors in the
    //  audio track, record a data track (but fail to record descriptors there)
    //  and still have the disk work.  As this form of error worked in NT 4.0, and
    //  since these disks really do exist, I don't want to change them.
    //
    //  If we wished to support all such media (we don't), it would be neccesary
    //  to clear this flag on finding ISO or HSG descriptors below.
    //
 
    if (FlagOn(Vcb->VcbState, VCB_STATE_AUDIO_DISK)) {
 
        return FALSE;
    }
 
    //
    //  We will make at most two passes through the volume descriptor sequence.
    //
    //  On the first pass we will query for the last session.  Using this
    //  as a starting offset we will attempt to mount the volume.  On any failure
    //  we will go to the second pass and try without using any multi-session
    //  information.
    //
    //  On the second pass we will start offset from sector zero.
    //
 
    while (!FoundVd && (ThisPass <= 2)) {
 
        //
        //  If we aren't at pass 1 then we start at sector 0.  Otherwise we
        //  try to look up the multi-session information.
        //
 
        BaseSector = 0;
 
        if (ThisPass == 1) {
 
            CdromToc = NULL;
 
            //
            //  Check for whether this device supports XA and multi-session.
            //
 
            _SEH2_TRY {
 
                //
                //  Allocate a buffer for the last session information.
                //
 
                CdromToc = FsRtlAllocatePoolWithTag( CdPagedPool,
                                                     sizeof( CDROM_TOC_LARGE ),
                                                     TAG_CDROM_TOC );
 
                RtlZeroMemory( CdromToc, sizeof( CDROM_TOC_LARGE ));
 
                //
                //  Query the last session information from the driver.
                //
 
                Status = CdPerformDevIoCtrl( IrpContext,
                                             IOCTL_CDROM_GET_LAST_SESSION,
                                             Vcb->TargetDeviceObject,
                                             CdromToc,
                                             sizeof( CDROM_TOC_LARGE ),
                                             FALSE,
                                             TRUE,
                                             NULL );
 
                //
                //  Raise an exception if there was an allocation failure.
                //
 
                if (Status == STATUS_INSUFFICIENT_RESOURCES) {
 
                    CdRaiseStatus( IrpContext, Status );
                }
 
                //
                //  We don't handle any errors yet.  We will hit that below
                //  as we try to scan the disk.  If we have last session information
                //  then modify the base sector.
                //
 
                if (NT_SUCCESS( Status ) &&
                    (CdromToc->FirstTrack != CdromToc->LastTrack)) {
 
                    PCHAR Source, Dest;
                    ULONG Count;
 
                    Count = 4;
 
                    //
                    //  The track address is BigEndian, we need to flip the bytes.
                    //
 
                    Source = (PCHAR) &CdromToc->TrackData[0].Address[3];
                    Dest = (PCHAR) &BaseSector;
 
                    do {
 
                        *Dest++ = *Source--;
 
                    } while (--Count);
 
                    //
                    //  Now adjust the base sector by the block factor of the
                    //  device.
                    //
 
                    BaseSector /= BlockFactor;
 
                //
                //  Make this look like the second pass since we are only using the
                //  first session.  No reason to retry on error.
                //
 
                } else {
 
                    ThisPass += 1;
                }
 
            } _SEH2_FINALLY {
 
                if (CdromToc != NULL) { CdFreePool( &CdromToc ); }
            } _SEH2_END;
        }
 
        //
        //  Compute the starting sector offset from the start of the session.
        //
 
        SectorOffset = FIRST_VD_SECTOR;
 
        //
        //  Start by assuming we have neither Hsg or Iso volumes.
        //
 
        VolumeFlags = 0;
 
        //
        //  Loop until either error encountered, primary volume descriptor is
        //  found or a terminal volume descriptor is found.
        //
 
        while (TRUE) {
 
            //
            //  Attempt to read the desired sector. Exit directly if operation
            //  not completed.
            //
            //  If this is pass 1 we will ignore errors in read sectors and just
            //  go to the next pass.
            //
 
            if (!CdReadSectors( IrpContext,
                                LlBytesFromSectors( BaseSector + SectorOffset ),
                                SECTOR_SIZE,
                                (BOOLEAN) ((ThisPass == 1) || ReturnOnError),
                                RawIsoVd,
                                Vcb->TargetDeviceObject )) {
 
                break;
            }
 
            //
            //  Check if either an ISO or HSG volume.
            //
 
            if (RtlEqualMemory( CdIsoId,
                                CdRvdId( RawIsoVd, VCB_STATE_ISO ),
                                VOL_ID_LEN )) {
 
                SetFlag( VolumeFlags, VCB_STATE_ISO );
 
            } else if (RtlEqualMemory( CdHsgId,
                                       CdRvdId( RawIsoVd, VCB_STATE_HSG ),
                                       VOL_ID_LEN )) {
 
                SetFlag( VolumeFlags, VCB_STATE_HSG );
 
            //
            //  We have neither so break out of the loop.
            //
 
            } else {
 
                 break;
            }
 
            //
            //  Break out if the version number is incorrect or this is
            //  a terminator.
            //
 
            if ((CdRvdVersion( RawIsoVd, VolumeFlags ) != VERSION_1) ||
                (CdRvdDescType( RawIsoVd, VolumeFlags ) == VD_TERMINATOR)) {
 
                break;
            }
 
            //
            //  If this is a primary volume descriptor then our search is over.
            //
 
            if (CdRvdDescType( RawIsoVd, VolumeFlags ) == VD_PRIMARY) {
 
                //
                //  If we are not in the verify path then initialize the
                //  fields in the Vcb with basic information from this
                //  descriptor.
                //
 
                if (!VerifyVolume) {
 
                    //
                    //  Set the flag for the volume type.
                    //
 
                    SetFlag( Vcb->VcbState, VolumeFlags );
 
                    //
                    //  Store the base sector and sector offset for the
                    //  primary volume descriptor.
                    //
 
                    Vcb->BaseSector = BaseSector;
                    Vcb->VdSectorOffset = SectorOffset;
                    Vcb->PrimaryVdSectorOffset = SectorOffset;
                }
 
                FoundVd = TRUE;
                break;
            }
 
            //
            //  Indicate that we're at the next sector.
            //
 
            SectorOffset += 1;
        }
 
        ThisPass += 1;
    }
 
    return FoundVd;
}

CdAllowExtendedDasdIo()

NTSTATUS CdAllowExtendedDasdIo	(	_Inout_ PIRP_CONTEXT	IrpContext,
		_Inout_ PIRP	Irp
	)

Definition at line 2705 of file fsctrl.c.

{
    NTSTATUS Status;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    PFCB Fcb;
    PCCB Ccb;
 
    PAGED_CODE();
 
    //
    //  Decode the file object, the only type of opens we accept are
    //  user volume opens.
    //
 
    if (CdDecodeFileObject( IrpContext, IrpSp->FileObject, &Fcb, &Ccb ) != UserVolumeOpen ) {
 
        Status = STATUS_INVALID_PARAMETER;
    }
    else {
 
        SetFlag( Ccb->Flags, CCB_FLAG_ALLOW_EXTENDED_DASD_IO );
        Status = STATUS_SUCCESS;
    }
 
    CdCompleteRequest( IrpContext, Irp, Status );
    return Status;
}

Referenced by _Success_().

CdFindActiveVolDescriptor()

VOID CdFindActiveVolDescriptor	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PVCB	Vcb,
		_Inout_updates_bytes_(ROUND_TO_PAGES(SECTOR_SIZE)) PCHAR	RawIsoVd,
		_In_ BOOLEAN	VerifyVolume
	)

Definition at line 3289 of file fsctrl.c.

{
    BOOLEAN FoundSecondaryVd = FALSE;
    ULONG SectorOffset = FIRST_VD_SECTOR;
 
    ULONG Length;
 
    ULONG Index;
 
    PAGED_CODE();
 
    //
    //  We only look for secondary volume descriptors on an Iso disk.
    //
 
    if ((FlagOn( Vcb->VcbState, VCB_STATE_ISO) || VerifyVolume) && !CdNoJoliet) {
 
        //
        //  Scan the volume descriptors from the beginning looking for a valid
        //  secondary or a terminator.
        //
 
        SectorOffset = FIRST_VD_SECTOR;
 
        while (TRUE) {
 
            //
            //  Read the next sector.  We should never have an error in this
            //  path.
            //
 
            CdReadSectors( IrpContext,
                           LlBytesFromSectors( Vcb->BaseSector + SectorOffset ),
                           SECTOR_SIZE,
                           FALSE,
                           RawIsoVd,
                           Vcb->TargetDeviceObject );
 
            //
            //  Break out if the version number or standard Id is incorrect.
            //  Also break out if this is a terminator.
            //
 
            if (!RtlEqualMemory( CdIsoId, CdRvdId( RawIsoVd, VCB_STATE_JOLIET ), VOL_ID_LEN ) ||
                (CdRvdVersion( RawIsoVd, VCB_STATE_JOLIET ) != VERSION_1) ||
                (CdRvdDescType( RawIsoVd, VCB_STATE_JOLIET ) == VD_TERMINATOR)) {
 
                break;
            }
 
            //
            //  We have a match if this is a secondary descriptor with a matching
            //  escape sequence.
            //
 
            if ((CdRvdDescType( RawIsoVd, VCB_STATE_JOLIET ) == VD_SECONDARY) &&
                (RtlEqualMemory( CdRvdEsc( RawIsoVd, VCB_STATE_JOLIET ),
                                 CdJolietEscape[0],
                                 ESC_SEQ_LEN ) ||
                 RtlEqualMemory( CdRvdEsc( RawIsoVd, VCB_STATE_JOLIET ),
                                 CdJolietEscape[1],
                                 ESC_SEQ_LEN ) ||
                 RtlEqualMemory( CdRvdEsc( RawIsoVd, VCB_STATE_JOLIET ),
                                 CdJolietEscape[2],
                                 ESC_SEQ_LEN ))) {
 
                if (!VerifyVolume)  {
 
                    //
                    //  Update the Vcb with the new volume descriptor.
                    //
 
                    ClearFlag( Vcb->VcbState, VCB_STATE_ISO );
                    SetFlag( Vcb->VcbState, VCB_STATE_JOLIET );
 
                    Vcb->VdSectorOffset = SectorOffset;
                }
 
                FoundSecondaryVd = TRUE;
                break;
            }
 
            //
            //  Otherwise move on to the next sector.
            //
 
            SectorOffset += 1;
        }
 
        //
        //  If we didn't find the secondary then recover the original volume
        //  descriptor stored in the second half of the RawIsoVd.
        //
 
        if (!FoundSecondaryVd) {
 
            RtlCopyMemory( RawIsoVd,
                           Add2Ptr( RawIsoVd, SECTOR_SIZE, PVOID ),
                           SECTOR_SIZE );
        }
    }
 
    //
    //  If we're in the verify path,  our work is done,  since we don't want
    //  to update any Vcb/Vpb values.
    //
 
    if (VerifyVolume)  {
 
        return;
    }
 
    //
    //  Compute the serial number and volume label from the volume descriptor.
    //
 
    Vcb->Vpb->SerialNumber = CdSerial32( RawIsoVd, SECTOR_SIZE );
 
    //
    //  Make sure the CD label will fit in the Vpb.
    //
 
    NT_ASSERT( VOLUME_ID_LENGTH * sizeof( WCHAR ) <= MAXIMUM_VOLUME_LABEL_LENGTH );
 
    //
    //  If this is not a Unicode label we must convert it to unicode.
    //
 
    if (!FlagOn( Vcb->VcbState, VCB_STATE_JOLIET )) {
 
        //
        //  Convert the label to unicode.  If we get any error then use a name
        //  length of zero.
        //
 
        Vcb->Vpb->VolumeLabelLength = 0;
 
        if (NT_SUCCESS( RtlOemToUnicodeN( &Vcb->Vpb->VolumeLabel[0],
                                          MAXIMUM_VOLUME_LABEL_LENGTH,
                                          &Length,
                                          (PCH)CdRvdVolId( RawIsoVd, Vcb->VcbState ),
                                          VOLUME_ID_LENGTH ))) {
 
            Vcb->Vpb->VolumeLabelLength = (USHORT) Length;
        }
 
    //
    //  We need to convert from big-endian to little endian.
    //
 
    } else {
 
        CdConvertBigToLittleEndian( IrpContext,
                                    (PCHAR) CdRvdVolId( RawIsoVd, Vcb->VcbState ),
                                    VOLUME_ID_LENGTH,
                                    (PCHAR) Vcb->Vpb->VolumeLabel );
 
        Vcb->Vpb->VolumeLabelLength = VOLUME_ID_LENGTH * sizeof( WCHAR );
    }
 
    //
    //  Strip the trailing spaces or zeroes from the name.
    //
 
    Index = Vcb->Vpb->VolumeLabelLength / sizeof( WCHAR );
 
    while (Index > 0) {
 
        if ((Vcb->Vpb->VolumeLabel[ Index - 1 ] != L'\0') &&
            (Vcb->Vpb->VolumeLabel[ Index - 1 ] != L' ')) {
 
            break;
        }
 
        Index -= 1;
    }
 
    //
    //  Now set the final length for the name.
    //
 
    Vcb->Vpb->VolumeLabelLength = (USHORT) (Index * sizeof( WCHAR ));
}

Referenced by _Success_().

CdIsPathnameValid()

NTSTATUS CdIsPathnameValid	(	_Inout_ PIRP_CONTEXT	IrpContext,
		_Inout_ PIRP	Irp
	)

Definition at line 2421 of file fsctrl.c.

{
    PAGED_CODE();
 
    CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
    return STATUS_SUCCESS;
}

Referenced by _Success_().

CdIsVolumeDirty()

NTSTATUS CdIsVolumeDirty	(	_Inout_ PIRP_CONTEXT	IrpContext,
		_Inout_ PIRP	Irp
	)

Definition at line 2259 of file fsctrl.c.

{
    PIO_STACK_LOCATION IrpSp;
 
    TYPE_OF_OPEN TypeOfOpen;
    PFCB Fcb;
    PCCB Ccb;
 
    PULONG VolumeState;
 
    PAGED_CODE();
 
    //
    //  Get the current stack location and extract the output
    //  buffer information.
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    //
    //  Get a pointer to the output buffer.
    //
 
    if (Irp->AssociatedIrp.SystemBuffer != NULL) {
 
        VolumeState = Irp->AssociatedIrp.SystemBuffer;
 
    } else {
 
        CdCompleteRequest( IrpContext, Irp, STATUS_INVALID_USER_BUFFER );
        return STATUS_INVALID_USER_BUFFER;
    }
 
    //
    //  Make sure the output buffer is large enough and then initialize
    //  the answer to be that the volume isn't dirty.
    //
 
    if (IrpSp->Parameters.FileSystemControl.OutputBufferLength < sizeof(ULONG)) {
 
        CdCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
        return STATUS_INVALID_PARAMETER;
    }
 
    *VolumeState = 0;
 
    //
    //  Decode the file object
    //
 
    TypeOfOpen = CdDecodeFileObject( IrpContext, IrpSp->FileObject, &Fcb, &Ccb );
 
    if (TypeOfOpen != UserVolumeOpen) {
 
        CdCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
        return STATUS_INVALID_PARAMETER;
    }
 
    if (Fcb->Vcb->VcbCondition != VcbMounted) {
 
        CdCompleteRequest( IrpContext, Irp, STATUS_VOLUME_DISMOUNTED );
        return STATUS_VOLUME_DISMOUNTED;
    }
 
    //
    //  Now set up to return the clean state.  CDs obviously can never be dirty
    //  but we want to make sure we have enforced the full semantics of this call.
    //
 
    Irp->IoStatus.Information = sizeof( ULONG );
 
    CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
    return STATUS_SUCCESS;
}

Referenced by _Success_().

CdIsVolumeMounted()

NTSTATUS CdIsVolumeMounted	(	_Inout_ PIRP_CONTEXT	IrpContext,
		_Inout_ PIRP	Irp
	)

Definition at line 2360 of file fsctrl.c.

{
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    PFCB Fcb;
    PCCB Ccb;
 
    PAGED_CODE();
 
    //
    //  Decode the file object.
    //
 
    CdDecodeFileObject( IrpContext, IrpSp->FileObject, &Fcb, &Ccb );
 
    if (Fcb != NULL) {
 
        //
        //  Disable PopUps, we want to return any error.
        //
 
        SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS );
 
        //
        //  Verify the Vcb.  This will raise in the error condition.
        //
 
        CdVerifyVcb( IrpContext, Fcb->Vcb );
    }
 
    CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
 
    return STATUS_SUCCESS;
}

Referenced by _Success_().

CdReMountOldVcb()

VOID CdReMountOldVcb	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PVCB	OldVcb,
		_Inout_ PVCB	NewVcb,
		_In_ PDEVICE_OBJECT	DeviceObjectWeTalkTo
	)

Definition at line 518 of file fsctrl.c.

{
    KIRQL SavedIrql;
    ULONG Index;
    PUCHAR Buffer;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    ObDereferenceObject( OldVcb->TargetDeviceObject );
 
    IoAcquireVpbSpinLock( &SavedIrql );
 
#ifdef _MSC_VER
#pragma prefast(suppress: 28175, "this is a filesystem driver, touching the vpb is allowed")
#endif
    NewVcb->Vpb->RealDevice->Vpb = OldVcb->Vpb;
 
    OldVcb->Vpb->RealDevice = NewVcb->Vpb->RealDevice;
    OldVcb->TargetDeviceObject = DeviceObjectWeTalkTo;
 
    CdUpdateVcbCondition( OldVcb, VcbMounted);
    CdUpdateMediaChangeCount( OldVcb, NewVcb->MediaChangeCount);
 
    ClearFlag( OldVcb->VcbState, VCB_STATE_VPB_NOT_ON_DEVICE);
 
    Buffer = OldVcb->SectorCacheBuffer = NewVcb->SectorCacheBuffer;
    NewVcb->SectorCacheBuffer = NULL;
 
    if (NULL != Buffer) {
 
        for (Index = 0; Index < CD_SEC_CACHE_CHUNKS; Index++) {
 
            OldVcb->SecCacheChunks[ Index].Buffer = Buffer;
            OldVcb->SecCacheChunks[ Index].BaseLbn = (ULONG)-1;
 
            Buffer += CD_SEC_CHUNK_BLOCKS * SECTOR_SIZE;
        }
    }
 
    IoReleaseVpbSpinLock( SavedIrql );
}

CdUnlockVolumeInternal()

NTSTATUS CdUnlockVolumeInternal	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PVCB	Vcb,
		_In_opt_ PFILE_OBJECT	FileObject
	)

Definition at line 288 of file fsctrl.c.

{
    NTSTATUS Status = STATUS_NOT_LOCKED;
    KIRQL SavedIrql;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Note that we check the VPB_LOCKED flag here rather than the Vcb
    //  lock flag.  The Vpb flag is only set for an explicit lock request,  not
    //  for the implicit lock obtained on a volume open with zero share mode.
    //
 
    IoAcquireVpbSpinLock( &SavedIrql );
 
    if (FlagOn(Vcb->Vpb->Flags, VPB_LOCKED) &&
        (FileObject == Vcb->VolumeLockFileObject))  {
 
        ClearFlag( Vcb->VcbState, VCB_STATE_LOCKED );
        ClearFlag( Vcb->Vpb->Flags, VPB_LOCKED);
        Vcb->VolumeLockFileObject = NULL;
        Status = STATUS_SUCCESS;
    }
 
    IoReleaseVpbSpinLock( SavedIrql );
 
    return Status;
}

Variable Documentation

CdDisable

BOOLEAN CdDisable = FALSE

Definition at line 29 of file fsctrl.c.

CdNoJoliet

BOOLEAN CdNoJoliet = FALSE

Definition at line 30 of file fsctrl.c.

Referenced by CdFindActiveVolDescriptor().