自学教程：C++ ExReleaseResourceLite函数代码示例

//.........这里部分代码省略.........	pIrpSp = IoGetCurrentIrpStackLocation(pIrp);	ASSERT(pIrp);	pFileObject = pIrpSp->FileObject;	ASSERT(pFileObject);	TypeOfOpen = xixfs_DecodeFileObject( pFileObject, &pFCB, &pCCB );    if (TypeOfOpen == UnopenedFileObject) {		RC = STATUS_INVALID_PARAMETER;        xixfs_CompleteRequest( pIrpContext, STATUS_INVALID_PARAMETER, 0 );        return RC;    }	DebugTrace(DEBUG_LEVEL_CRITICAL, DEBUG_TARGET_ALL, 					("!!!!VolumeInformation  pCCB(%p)/n", pCCB));	pVCB = pFCB->PtrVCB;	ASSERT_VCB(pVCB);	Wait = XIXCORE_TEST_FLAGS(pIrpContext->IrpContextFlags, XIFSD_IRP_CONTEXT_WAIT);		if(!ExAcquireResourceSharedLite(&(pVCB->VCBResource), Wait)){		DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_VOLINFO|DEBUG_TARGET_IRPCONTEXT),					("PostRequest IrpContext(%p) Irp(%p)/n", pIrpContext, pIrp));		RC = xixfs_PostRequest(pIrpContext, pIrp);		return RC;	}	try{		Length = pIrpSp->Parameters.QueryVolume.Length ;		DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_VOLINFO|DEBUG_TARGET_IRPCONTEXT),					 ("pIrpSp->Parameters.QueryVolume.FsInformationClass (0x%x)/n", 					 pIrpSp->Parameters.QueryVolume.FsInformationClass));			switch (pIrpSp->Parameters.QueryVolume.FsInformationClass) {		case FileFsSizeInformation:		{				RC = xixfs_QueryFsSizeInfo( pIrpContext, pVCB, pIrp->AssociatedIrp.SystemBuffer, Length, &BytesToReturn );			xixfs_CompleteRequest(pIrpContext, RC, BytesToReturn);			break;		}		case FileFsVolumeInformation:		{			RC = xixfs_QueryFsVolumeInfo( pIrpContext, pVCB, pIrp->AssociatedIrp.SystemBuffer, Length, &BytesToReturn );			xixfs_CompleteRequest(pIrpContext, RC, BytesToReturn);			break;		}		case FileFsDeviceInformation:		{			RC = xixfs_QueryFsDeviceInfo( pIrpContext, pVCB, pIrp->AssociatedIrp.SystemBuffer, Length, &BytesToReturn );			xixfs_CompleteRequest(pIrpContext, RC, BytesToReturn);			break;		}		case FileFsAttributeInformation:		{			RC = xixfs_QueryFsAttributeInfo( pIrpContext, pVCB, pIrp->AssociatedIrp.SystemBuffer, Length, &BytesToReturn );			xixfs_CompleteRequest(pIrpContext, RC, BytesToReturn);			break;		}				case FileFsFullSizeInformation:		{			RC = xixfs_QueryFsFullSizeInfo(pIrpContext, pVCB, pIrp->AssociatedIrp.SystemBuffer, Length, &BytesToReturn);			xixfs_CompleteRequest(pIrpContext, RC, BytesToReturn);			break;		}		default:			DebugTrace( DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL,				("default Not supported Volume Info %ld/n",pIrpSp->Parameters.QueryVolume.FsInformationClass));			RC = STATUS_INVALID_PARAMETER;			xixfs_CompleteRequest(pIrpContext, RC, 0);		break;		 }			}finally{		ExReleaseResourceLite(&(pVCB->VCBResource));	}	DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_VOLINFO|DEBUG_TARGET_IRPCONTEXT),		("Exit xixfs_CommonQueryVolumeInformation /n"));	return RC;	}

VOIDDokanCompleteSetInformation(	__in PIRP_ENTRY		IrpEntry,	__in PEVENT_INFORMATION EventInfo	){	PIRP				irp;	PIO_STACK_LOCATION	irpSp;	NTSTATUS			status;	ULONG				info	 = 0;	PDokanCCB			ccb;	PDokanFCB			fcb;	UNICODE_STRING		oldFileName;	FILE_INFORMATION_CLASS infoClass;	__try {		DDbgPrint("==> DokanCompleteSetInformation/n");		irp = IrpEntry->Irp;		irpSp = IrpEntry->IrpSp;		ccb = IrpEntry->FileObject->FsContext2;		ASSERT(ccb != NULL);		ExAcquireResourceExclusiveLite(&ccb->Resource, TRUE);		fcb = ccb->Fcb;		ASSERT(fcb != NULL);		ccb->UserContext = EventInfo->Context;		status = EventInfo->Status;		info = EventInfo->BufferLength;		infoClass = irpSp->Parameters.SetFile.FileInformationClass;		RtlZeroMemory(&oldFileName, sizeof(UNICODE_STRING));		if (NT_SUCCESS(status)) {						if (infoClass == FileDispositionInformation) {				if (EventInfo->Delete.DeleteOnClose) {					if (!MmFlushImageSection(						&fcb->SectionObjectPointers,						MmFlushForDelete)) {						DDbgPrint("  Cannot delete user mapped image/n");						status = STATUS_CANNOT_DELETE;					} else {						ccb->Flags |= DOKAN_DELETE_ON_CLOSE;						fcb->Flags |= DOKAN_DELETE_ON_CLOSE;						DDbgPrint("   FileObject->DeletePending = TRUE/n");						IrpEntry->FileObject->DeletePending = TRUE;					}				} else {					ccb->Flags &= ~DOKAN_DELETE_ON_CLOSE;					fcb->Flags &= ~DOKAN_DELETE_ON_CLOSE;					DDbgPrint("   FileObject->DeletePending = FALSE/n");					IrpEntry->FileObject->DeletePending = FALSE;				}			}			// if rename is executed, reassign the file name			if(infoClass == FileRenameInformation) {				PVOID buffer = NULL;				ExAcquireResourceExclusiveLite(&fcb->Resource, TRUE);				// this is used to inform rename in the bellow switch case				oldFileName.Buffer = fcb->FileName.Buffer;				oldFileName.Length = (USHORT)fcb->FileName.Length;				oldFileName.MaximumLength = (USHORT)fcb->FileName.Length;				// copy new file name				buffer = ExAllocatePool(EventInfo->BufferLength+sizeof(WCHAR));				if (buffer == NULL) {					status = STATUS_INSUFFICIENT_RESOURCES;					ExReleaseResourceLite(&fcb->Resource);					ExReleaseResourceLite(&ccb->Resource);					__leave;				}				fcb->FileName.Buffer = buffer;				ASSERT(fcb->FileName.Buffer != NULL);				RtlZeroMemory(fcb->FileName.Buffer, EventInfo->BufferLength+sizeof(WCHAR));				RtlCopyMemory(fcb->FileName.Buffer, EventInfo->Buffer, EventInfo->BufferLength);				fcb->FileName.Length = (USHORT)EventInfo->BufferLength;				fcb->FileName.MaximumLength = (USHORT)EventInfo->BufferLength;				ExReleaseResourceLite(&fcb->Resource);			}		}//.........这里部分代码省略.........

//.........这里部分代码省略.........    }    NonPagedCcb = Ccb->NonPagedCcb;    ExAcquireResourceExclusiveLite(&NonPagedCcb->Lock, TRUE);    if (Ccb->NamedPipeState == FILE_PIPE_DISCONNECTED_STATE || Ccb->NamedPipeState == FILE_PIPE_LISTENING_STATE)    {        IoStatus->Status = Ccb->NamedPipeState != FILE_PIPE_DISCONNECTED_STATE ? STATUS_PIPE_LISTENING : STATUS_PIPE_DISCONNECTED;        ReadOk = TRUE;        goto Quickie;    }    ASSERT((Ccb->NamedPipeState == FILE_PIPE_CONNECTED_STATE) || (Ccb->NamedPipeState == FILE_PIPE_CLOSING_STATE));    if ((NamedPipeEnd == FILE_PIPE_SERVER_END && Ccb->Fcb->NamedPipeConfiguration == FILE_PIPE_OUTBOUND) ||        (NamedPipeEnd == FILE_PIPE_CLIENT_END && Ccb->Fcb->NamedPipeConfiguration == FILE_PIPE_INBOUND))    {        IoStatus->Status = STATUS_INVALID_PARAMETER;        ReadOk = TRUE;        goto Quickie;    }    if (NamedPipeEnd == FILE_PIPE_SERVER_END)    {        ReadQueue = &Ccb->DataQueue[FILE_PIPE_INBOUND];    }    else    {        ReadQueue = &Ccb->DataQueue[FILE_PIPE_OUTBOUND];    }    EventBuffer = NonPagedCcb->EventBuffer[NamedPipeEnd];    if (ReadQueue->QueueState == WriteEntries)    {        *IoStatus = NpReadDataQueue(ReadQueue,                                    FALSE,                                    FALSE,                                    Buffer,                                    BufferSize,                                    Ccb->ReadMode[NamedPipeEnd],                                    Ccb,                                    List);        if (!NT_SUCCESS(IoStatus->Status))        {            ReadOk = TRUE;            goto Quickie;        }        ReadOk = TRUE;        if (EventBuffer) KeSetEvent(EventBuffer->Event, IO_NO_INCREMENT, FALSE);        goto Quickie;    }    if (Ccb->NamedPipeState == FILE_PIPE_CLOSING_STATE)    {        IoStatus->Status = STATUS_PIPE_BROKEN;        ReadOk = TRUE;        if (EventBuffer) KeSetEvent(EventBuffer->Event, IO_NO_INCREMENT, FALSE);        goto Quickie;    }    if (Ccb->CompletionMode[NamedPipeEnd] == FILE_PIPE_COMPLETE_OPERATION)    {        IoStatus->Status = STATUS_PIPE_EMPTY;        ReadOk = TRUE;        if (EventBuffer) KeSetEvent(EventBuffer->Event, IO_NO_INCREMENT, FALSE);        goto Quickie;    }    if (!Irp)    {        ReadOk = FALSE;        goto Quickie;    }    Status = NpAddDataQueueEntry(NamedPipeEnd,                                 Ccb,                                 ReadQueue,                                 ReadEntries,                                 Buffered,                                 BufferSize,                                 Irp,                                 NULL,                                 0);    IoStatus->Status = Status;    if (!NT_SUCCESS(Status))    {        ReadOk = FALSE;    }    else    {        ReadOk = TRUE;        if (EventBuffer) KeSetEvent(EventBuffer->Event, IO_NO_INCREMENT, FALSE);    }Quickie:    ExReleaseResourceLite(&Ccb->NonPagedCcb->Lock);    return ReadOk;}

//.........这里部分代码省略.........   /* Initialize this resource early ... it's used in VfatCleanup */   ExInitializeResourceLite(&DeviceExt->DirResource);   DeviceExt->FATFileObject = IoCreateStreamFileObject(NULL, DeviceExt->StorageDevice);   Fcb = vfatNewFCB(DeviceExt, &NameU);   if (Fcb == NULL)   {      Status = STATUS_INSUFFICIENT_RESOURCES;      goto ByeBye;   }   Ccb = ExAllocateFromNPagedLookasideList(&VfatGlobalData->CcbLookasideList);   if (Ccb == NULL)   {      Status =  STATUS_INSUFFICIENT_RESOURCES;      goto ByeBye;   }   RtlZeroMemory(Ccb, sizeof (VFATCCB));   DeviceExt->FATFileObject->FsContext = Fcb;   DeviceExt->FATFileObject->FsContext2 = Ccb;   DeviceExt->FATFileObject->SectionObjectPointer = &Fcb->SectionObjectPointers;   DeviceExt->FATFileObject->PrivateCacheMap = NULL;   DeviceExt->FATFileObject->Vpb = DeviceObject->Vpb;   Fcb->FileObject = DeviceExt->FATFileObject;   Fcb->Flags |= FCB_IS_FAT;   Fcb->RFCB.FileSize.QuadPart = DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector;   Fcb->RFCB.ValidDataLength = Fcb->RFCB.FileSize;   Fcb->RFCB.AllocationSize = Fcb->RFCB.FileSize;   CcInitializeCacheMap(DeviceExt->FATFileObject,                        (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),                        TRUE,                        &VfatGlobalData->CacheMgrCallbacks,                        Fcb);   DeviceExt->LastAvailableCluster = 2;   ExInitializeResourceLite(&DeviceExt->FatResource);   InitializeListHead(&DeviceExt->FcbListHead);   VolumeFcb = vfatNewFCB(DeviceExt, &VolumeNameU);   if (VolumeFcb == NULL)   {      Status = STATUS_INSUFFICIENT_RESOURCES;      goto ByeBye;   }   VolumeFcb->Flags = FCB_IS_VOLUME;   VolumeFcb->RFCB.FileSize.QuadPart = DeviceExt->FatInfo.Sectors * DeviceExt->FatInfo.BytesPerSector;   VolumeFcb->RFCB.ValidDataLength = VolumeFcb->RFCB.FileSize;   VolumeFcb->RFCB.AllocationSize = VolumeFcb->RFCB.FileSize;   DeviceExt->VolumeFcb = VolumeFcb;   ExAcquireResourceExclusiveLite(&VfatGlobalData->VolumeListLock, TRUE);   InsertHeadList(&VfatGlobalData->VolumeListHead, &DeviceExt->VolumeListEntry);   ExReleaseResourceLite(&VfatGlobalData->VolumeListLock);   /* read serial number */   DeviceObject->Vpb->SerialNumber = DeviceExt->FatInfo.VolumeID;   /* read volume label */   ReadVolumeLabel(DeviceExt,  DeviceObject->Vpb);   /* read clean shutdown bit status */   Status = GetNextCluster(DeviceExt, 1, &eocMark);   if (NT_SUCCESS(Status))   {      if (eocMark & DeviceExt->CleanShutBitMask)      {         /* unset clean shutdown bit */         eocMark &= ~DeviceExt->CleanShutBitMask;         WriteCluster(DeviceExt, 1, eocMark);         VolumeFcb->Flags |= VCB_CLEAR_DIRTY;      }   }   VolumeFcb->Flags |= VCB_IS_DIRTY;   FsRtlNotifyVolumeEvent(DeviceExt->FATFileObject, FSRTL_VOLUME_MOUNT);   Status = STATUS_SUCCESS;ByeBye:  if (!NT_SUCCESS(Status))  {     // cleanup     if (DeviceExt && DeviceExt->FATFileObject)        ObDereferenceObject (DeviceExt->FATFileObject);     if (Fcb)        vfatDestroyFCB(Fcb);     if (Ccb)        vfatDestroyCCB(Ccb);     if (DeviceObject)       IoDeleteDevice(DeviceObject);     if (VolumeFcb)        vfatDestroyFCB(VolumeFcb);  }  return Status;}

NTSTATUSDokanDispatchDeviceControl(__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp)/*++Routine Description:        This device control dispatcher handles IOCTLs.Arguments:        DeviceObject - Context for the activity.        Irp 		 - The device control argument block.Return Value:        NTSTATUS--*/{  PDokanVCB vcb;  PDokanDCB dcb;  PIO_STACK_LOCATION irpSp;  NTSTATUS status = STATUS_NOT_IMPLEMENTED;  ULONG controlCode = 0;  ULONG outputLength = 0;  // {DCA0E0A5-D2CA-4f0f-8416-A6414657A77A}  // GUID dokanGUID = { 0xdca0e0a5, 0xd2ca, 0x4f0f, { 0x84, 0x16, 0xa6, 0x41,  // 0x46, 0x57, 0xa7, 0x7a } };  __try {    Irp->IoStatus.Information = 0;    irpSp = IoGetCurrentIrpStackLocation(Irp);    outputLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength;    controlCode = irpSp->Parameters.DeviceIoControl.IoControlCode;    if (controlCode != IOCTL_EVENT_WAIT && controlCode != IOCTL_EVENT_INFO &&        controlCode != IOCTL_KEEPALIVE) {      DDbgPrint("==> DokanDispatchIoControl/n");      DDbgPrint("  ProcessId %lu/n", IoGetRequestorProcessId(Irp));    }    vcb = DeviceObject->DeviceExtension;    PrintIdType(vcb);    if (GetIdentifierType(vcb) == DGL) {      status = GlobalDeviceControl(DeviceObject, Irp);      __leave;    } else if (GetIdentifierType(vcb) == DCB) {      status = DiskDeviceControl(DeviceObject, Irp);      __leave;    } else if (GetIdentifierType(vcb) != VCB) {      status = STATUS_INVALID_PARAMETER;      __leave;    }    dcb = vcb->Dcb;    switch (irpSp->Parameters.DeviceIoControl.IoControlCode) {    case IOCTL_EVENT_WAIT:      DDbgPrint("  IOCTL_EVENT_WAIT/n");      status = DokanRegisterPendingIrpForEvent(DeviceObject, Irp);      break;    case IOCTL_EVENT_INFO:      // DDbgPrint("  IOCTL_EVENT_INFO/n");      status = DokanCompleteIrp(DeviceObject, Irp);      break;    case IOCTL_EVENT_RELEASE:      DDbgPrint("  IOCTL_EVENT_RELEASE/n");      status = DokanEventRelease(DeviceObject);      break;    case IOCTL_EVENT_WRITE:      DDbgPrint("  IOCTL_EVENT_WRITE/n");      status = DokanEventWrite(DeviceObject, Irp);      break;    case IOCTL_KEEPALIVE:      DDbgPrint("  IOCTL_KEEPALIVE/n");      if (dcb->Mounted) {        ExAcquireResourceExclusiveLite(&dcb->Resource, TRUE);        DokanUpdateTimeout(&dcb->TickCount, DOKAN_KEEPALIVE_TIMEOUT);        ExReleaseResourceLite(&dcb->Resource);        status = STATUS_SUCCESS;      } else {        DDbgPrint(" device is not mounted/n");        status = STATUS_INSUFFICIENT_RESOURCES;      }      break;    case IOCTL_RESET_TIMEOUT:      status = DokanResetPendingIrpTimeout(DeviceObject, Irp);      break;    case IOCTL_GET_ACCESS_TOKEN:      status = DokanGetAccessToken(DeviceObject, Irp);//.........这里部分代码省略.........

// start event dispatchingNTSTATUSDokanEventStart(    __in PDEVICE_OBJECT DeviceObject,    __in PIRP Irp   ){	ULONG				outBufferLen;	ULONG				inBufferLen;	PVOID				buffer;	PIO_STACK_LOCATION	irpSp;	EVENT_START			eventStart;	PEVENT_DRIVER_INFO	driverInfo;	PDOKAN_GLOBAL		dokanGlobal;	PDokanDCB			dcb;	NTSTATUS			status;	DEVICE_TYPE			deviceType;	ULONG				deviceCharacteristics;	WCHAR				baseGuidString[64];	GUID				baseGuid = DOKAN_BASE_GUID;	UNICODE_STRING		unicodeGuid;	ULONG				deviceNamePos;		DDbgPrint("==> DokanEventStart/n");	dokanGlobal = DeviceObject->DeviceExtension;	if (GetIdentifierType(dokanGlobal) != DGL) {		return STATUS_INVALID_PARAMETER;	}	irpSp = IoGetCurrentIrpStackLocation(Irp);	outBufferLen = irpSp->Parameters.DeviceIoControl.OutputBufferLength;	inBufferLen = irpSp->Parameters.DeviceIoControl.InputBufferLength;	if (outBufferLen != sizeof(EVENT_DRIVER_INFO) ||		inBufferLen != sizeof(EVENT_START)) {		return STATUS_INSUFFICIENT_RESOURCES;	}	RtlCopyMemory(&eventStart, Irp->AssociatedIrp.SystemBuffer, sizeof(EVENT_START));	driverInfo = Irp->AssociatedIrp.SystemBuffer;	if (eventStart.UserVersion != DOKAN_DRIVER_VERSION) {		driverInfo->DriverVersion = DOKAN_DRIVER_VERSION;		driverInfo->Status = DOKAN_START_FAILED;		Irp->IoStatus.Status = STATUS_SUCCESS;		Irp->IoStatus.Information = sizeof(EVENT_DRIVER_INFO);		return STATUS_SUCCESS;	}	deviceCharacteristics = FILE_DEVICE_IS_MOUNTED;	switch (eventStart.DeviceType) {	case DOKAN_DISK_FILE_SYSTEM:		deviceType = FILE_DEVICE_DISK_FILE_SYSTEM;		break;	case DOKAN_NETWORK_FILE_SYSTEM:		deviceType = FILE_DEVICE_NETWORK_FILE_SYSTEM;		deviceCharacteristics |= FILE_REMOTE_DEVICE;		break;	default:		DDbgPrint("  Unknown device type: %d/n", eventStart.DeviceType);		deviceType = FILE_DEVICE_DISK_FILE_SYSTEM;	}	if (eventStart.Flags & DOKAN_EVENT_REMOVABLE) {		DDbgPrint("  DeviceCharacteristics |= FILE_REMOVABLE_MEDIA/n");		deviceCharacteristics |= FILE_REMOVABLE_MEDIA;	}	baseGuid.Data2 = (USHORT)(dokanGlobal->MountId & 0xFFFF) ^ baseGuid.Data2;	baseGuid.Data3 = (USHORT)(dokanGlobal->MountId >> 16) ^ baseGuid.Data3;	status = RtlStringFromGUID(&baseGuid, &unicodeGuid);	if (!NT_SUCCESS(status)) {		return status;	}	RtlZeroMemory(baseGuidString, sizeof(baseGuidString));	RtlStringCchCopyW(baseGuidString, sizeof(baseGuidString) / sizeof(WCHAR), unicodeGuid.Buffer);	RtlFreeUnicodeString(&unicodeGuid);	InterlockedIncrement(&dokanGlobal->MountId);	KeEnterCriticalRegion();	ExAcquireResourceExclusiveLite(&dokanGlobal->Resource, TRUE);	status = DokanCreateDiskDevice(				DeviceObject->DriverObject,				dokanGlobal->MountId,				baseGuidString,				dokanGlobal,				deviceType,				deviceCharacteristics,				&dcb);	if (!NT_SUCCESS(status)) {		ExReleaseResourceLite(&dokanGlobal->Resource);		KeLeaveCriticalRegion();//.........这里部分代码省略.........

/* * @implemented */VOIDNTAPIIoRegisterFileSystem(IN PDEVICE_OBJECT DeviceObject){    PLIST_ENTRY FsList = NULL;    PAGED_CODE();    /* Acquire the FS lock */    KeEnterCriticalRegion();    ExAcquireResourceExclusiveLite(&IopDatabaseResource, TRUE);    /* Check what kind of FS this is */    if (DeviceObject->DeviceType == FILE_DEVICE_DISK_FILE_SYSTEM)    {        /* Use the disk list */        FsList = &IopDiskFileSystemQueueHead;    }    else if (DeviceObject->DeviceType == FILE_DEVICE_NETWORK_FILE_SYSTEM)    {        /* Use the network device list */        FsList = &IopNetworkFileSystemQueueHead;    }    else if (DeviceObject->DeviceType == FILE_DEVICE_CD_ROM_FILE_SYSTEM)    {        /* Use the CD-ROM list */        FsList = &IopCdRomFileSystemQueueHead;    }    else if (DeviceObject->DeviceType == FILE_DEVICE_TAPE_FILE_SYSTEM)    {        /* Use the tape list */        FsList = &IopTapeFileSystemQueueHead;    }    /* Make sure that we have a valid list */    if (FsList)    {        /* Check if we should insert it at the top or bottom of the list */        if (DeviceObject->Flags & DO_LOW_PRIORITY_FILESYSTEM)        {            /* At the bottom */            InsertTailList(FsList->Blink, &DeviceObject->Queue.ListEntry);        }        else        {            /* On top */            InsertHeadList(FsList, &DeviceObject->Queue.ListEntry);        }    }    /* Update operations counter */    IopFsRegistrationOps++;    /* Clear the initializing flag */    DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;    /* Notify file systems of the addition */    IopNotifyFileSystemChange(DeviceObject, TRUE);    /* Release the FS Lock */    ExReleaseResourceLite(&IopDatabaseResource);    KeLeaveCriticalRegion();    /* Ensure driver won't be unloaded */    IopInterlockedIncrementUlong(LockQueueIoDatabaseLock, (PULONG)&DeviceObject->ReferenceCount);}

NTSTATUSVfatFlushVolume(    PDEVICE_EXTENSION DeviceExt,    PVFATFCB VolumeFcb){    PLIST_ENTRY ListEntry;    PVFATFCB Fcb;    NTSTATUS Status, ReturnStatus = STATUS_SUCCESS;    PIRP Irp;    KEVENT Event;    IO_STATUS_BLOCK IoStatusBlock;    DPRINT("VfatFlushVolume(DeviceExt %p, VolumeFcb %p)/n", DeviceExt, VolumeFcb);    ASSERT(VolumeFcb == DeviceExt->VolumeFcb);    ListEntry = DeviceExt->FcbListHead.Flink;    while (ListEntry != &DeviceExt->FcbListHead)    {        Fcb = CONTAINING_RECORD(ListEntry, VFATFCB, FcbListEntry);        ListEntry = ListEntry->Flink;        if (!vfatFCBIsDirectory(Fcb))        {            ExAcquireResourceExclusiveLite(&Fcb->MainResource, TRUE);            Status = VfatFlushFile(DeviceExt, Fcb);            ExReleaseResourceLite (&Fcb->MainResource);            if (!NT_SUCCESS(Status))            {                DPRINT1("VfatFlushFile failed, status = %x/n", Status);                ReturnStatus = Status;            }        }        /* FIXME: Stop flushing if this is a removable media and the media was removed */    }    ListEntry = DeviceExt->FcbListHead.Flink;    while (ListEntry != &DeviceExt->FcbListHead)    {        Fcb = CONTAINING_RECORD(ListEntry, VFATFCB, FcbListEntry);        ListEntry = ListEntry->Flink;        if (vfatFCBIsDirectory(Fcb))        {            ExAcquireResourceExclusiveLite(&Fcb->MainResource, TRUE);            Status = VfatFlushFile(DeviceExt, Fcb);            ExReleaseResourceLite (&Fcb->MainResource);            if (!NT_SUCCESS(Status))            {                DPRINT1("VfatFlushFile failed, status = %x/n", Status);                ReturnStatus = Status;            }        }        /* FIXME: Stop flushing if this is a removable media and the media was removed */    }    Fcb = (PVFATFCB) DeviceExt->FATFileObject->FsContext;    ExAcquireResourceExclusiveLite(&DeviceExt->FatResource, TRUE);    Status = VfatFlushFile(DeviceExt, Fcb);    ExReleaseResourceLite(&DeviceExt->FatResource);    /* Prepare an IRP to flush device buffers */    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_FLUSH_BUFFERS,                                       DeviceExt->StorageDevice,                                       NULL, 0, NULL, &Event,                                       &IoStatusBlock);    if (Irp != NULL)    {        KeInitializeEvent(&Event, NotificationEvent, FALSE);        Status = IoCallDriver(DeviceExt->StorageDevice, Irp);        if (Status == STATUS_PENDING)        {            KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);            Status = IoStatusBlock.Status;        }        /* Ignore device not supporting flush operation */        if (Status == STATUS_INVALID_DEVICE_REQUEST)        {            DPRINT1("Flush not supported, ignored/n");            Status = STATUS_SUCCESS;        }    }    else    {        Status = STATUS_INSUFFICIENT_RESOURCES;    }    if (!NT_SUCCESS(Status))    {        DPRINT1("VfatFlushFile failed, status = %x/n", Status);        ReturnStatus = Status;    }    return ReturnStatus;}

/* * @implemented */NTSTATUSNTAPIIoRegisterFsRegistrationChange(IN PDRIVER_OBJECT DriverObject,                               IN PDRIVER_FS_NOTIFICATION DriverNotificationRoutine){    PFS_CHANGE_NOTIFY_ENTRY Entry;    PAGED_CODE();    /* Acquire the list lock */    KeEnterCriticalRegion();    ExAcquireResourceExclusiveLite(&IopDatabaseResource, TRUE);    /* Check if that driver is already registered (successive calls)     * See MSDN note: http://msdn.microsoft.com/en-us/library/ff548499%28v=vs.85%29.aspx     */    if (!IsListEmpty(&IopFsNotifyChangeQueueHead))    {        Entry = CONTAINING_RECORD(IopFsNotifyChangeQueueHead.Blink,                                  FS_CHANGE_NOTIFY_ENTRY,                                  FsChangeNotifyList);        if (Entry->DriverObject == DriverObject &&            Entry->FSDNotificationProc == DriverNotificationRoutine)        {            /* Release the lock */            ExReleaseResourceLite(&IopDatabaseResource);            return STATUS_DEVICE_ALREADY_ATTACHED;        }    }    /* Allocate a notification entry */    Entry = ExAllocatePoolWithTag(PagedPool,                                  sizeof(FS_CHANGE_NOTIFY_ENTRY),                                  TAG_FS_CHANGE_NOTIFY);    if (!Entry)    {        /* Release the lock */        ExReleaseResourceLite(&IopDatabaseResource);        return STATUS_INSUFFICIENT_RESOURCES;    }    /* Save the driver object and notification routine */    Entry->DriverObject = DriverObject;    Entry->FSDNotificationProc = DriverNotificationRoutine;    /* Insert it into the notification list */    InsertTailList(&IopFsNotifyChangeQueueHead, &Entry->FsChangeNotifyList);    /* Start notifying all already present FS */    IopNotifyAlreadyRegisteredFileSystems(&IopNetworkFileSystemQueueHead, DriverNotificationRoutine, FALSE);    IopNotifyAlreadyRegisteredFileSystems(&IopCdRomFileSystemQueueHead, DriverNotificationRoutine, TRUE);    IopNotifyAlreadyRegisteredFileSystems(&IopDiskFileSystemQueueHead, DriverNotificationRoutine, TRUE);    IopNotifyAlreadyRegisteredFileSystems(&IopTapeFileSystemQueueHead, DriverNotificationRoutine, TRUE);    /* Release the lock */    ExReleaseResourceLite(&IopDatabaseResource);    KeLeaveCriticalRegion();    /* Reference the driver */    ObReferenceObject(DriverObject);    return STATUS_SUCCESS;}

//.........这里部分代码省略.........            /* Allocate the IRP */            Irp = IoAllocateIrp(AttachedDeviceObject->StackSize +                                (UCHAR)FsStackOverhead,                                TRUE);            if (!Irp)            {                /* Fail */                Status =  STATUS_INSUFFICIENT_RESOURCES;                break;            }            /* Setup the IRP */            Irp->UserIosb = &IoStatusBlock;            Irp->UserEvent = &Event;            Irp->Tail.Overlay.Thread = PsGetCurrentThread();            Irp->Flags = IRP_MOUNT_COMPLETION | IRP_SYNCHRONOUS_PAGING_IO;            Irp->RequestorMode = KernelMode;            /* Get the I/O Stack location and set it up */            StackPtr = IoGetNextIrpStackLocation(Irp);            StackPtr->MajorFunction = IRP_MJ_FILE_SYSTEM_CONTROL;            StackPtr->MinorFunction = IRP_MN_MOUNT_VOLUME;            StackPtr->Flags = AllowRawMount;            StackPtr->Parameters.MountVolume.Vpb = DeviceObject->Vpb;            StackPtr->Parameters.MountVolume.DeviceObject =                AttachedDeviceObject;            /* Save registration operations */            RegistrationOps = IopFsRegistrationOps;            /* Release locks */            IopInterlockedIncrementUlong(LockQueueIoDatabaseLock, (PULONG)&DeviceObject->ReferenceCount);            ExReleaseResourceLite(&IopDatabaseResource);            /* Call the driver */            Status = IoCallDriver(FileSystemDeviceObject, Irp);            if (Status == STATUS_PENDING)            {                /* Wait on it */                KeWaitForSingleObject(&Event,                                      Executive,                                      KernelMode,                                      FALSE,                                      NULL);                Status = IoStatusBlock.Status;            }            ExAcquireResourceSharedLite(&IopDatabaseResource, TRUE);            IopInterlockedDecrementUlong(LockQueueIoDatabaseLock, (PULONG)&DeviceObject->ReferenceCount);            /* Check if mounting was successful */            if (NT_SUCCESS(Status))            {                /* Mount the VPB */                *Vpb = IopMountInitializeVpb(DeviceObject,                                             AttachedDeviceObject,                                             (DeviceObject->Vpb->Flags &                                              VPB_RAW_MOUNT));            }            else            {                /* Check if we failed because of the user */                if ((IoIsErrorUserInduced(Status)) &&                    (IoStatusBlock.Information == 1))                {

//.........这里部分代码省略.........                Vcb->PartitionInformation.PartitionLength.QuadPart  ) {            Irp->IoStatus.Information = 0;            Status = STATUS_END_OF_FILE;            __leave;        }        if (ByteOffset.QuadPart + Length > Vcb->Header.FileSize.QuadPart) {            Length = (ULONG)(Vcb->Header.FileSize.QuadPart - ByteOffset.QuadPart);        }        /*         *  User direct volume access         */        if (Ccb != NULL && !PagingIo) {            if (!ExAcquireResourceExclusiveLite(                        &Vcb->MainResource,                        IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) )) {                Status = STATUS_PENDING;                __leave;            }            MainResourceAcquired = TRUE;            if (!FlagOn(Ccb->Flags, CCB_VOLUME_DASD_PURGE)) {                if (!FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED)) {                    Ext2FlushVolume(IrpContext, Vcb, FALSE);                }                SetFlag(Ccb->Flags, CCB_VOLUME_DASD_PURGE);            }            ExReleaseResourceLite(&Vcb->MainResource);            MainResourceAcquired = FALSE;            /* will do Nocache i/o */        }        /*         *  I/O to volume StreamObject         */        if (!Nocache) {            if (IsFlagOn(IrpContext->MinorFunction, IRP_MN_MDL)) {                CcMdlRead(                    Vcb->Volume,                    &ByteOffset,                    Length,                    &Irp->MdlAddress,                    &Irp->IoStatus );                Status = Irp->IoStatus.Status;            } else {                Buffer = Ext2GetUserBuffer(Irp);                if (Buffer == NULL) {                    DbgBreak();                    Status = STATUS_INVALID_USER_BUFFER;                    __leave;                }                if (!CcCopyRead(

//.........这里部分代码省略.........                    }                }            }            Status = Ext2LockUserBuffer(                         IrpContext->Irp,                         BytesRead,                         IoReadAccess );            if (!NT_SUCCESS(Status)) {                __leave;            }            Status = Ext2ReadInode(                         IrpContext,                         Vcb,                         Fcb->Mcb,                         ByteOffset.QuadPart,                         NULL,                         BytesRead,                         TRUE,                         NULL );            /* we need re-queue this request in case STATUS_CANT_WAIT               and fail it in other failure cases  */            if (!NT_SUCCESS(Status)) {                __leave;            }            /* pended by low level device */            if (Status == STATUS_PENDING) {                IrpContext->Irp = Irp = NULL;                __leave;            }            Irp = IrpContext->Irp;            ASSERT(Irp);            Status = Irp->IoStatus.Status;            if (!NT_SUCCESS(Status)) {                Ext2NormalizeAndRaiseStatus(IrpContext, Status);            }        }        Irp->IoStatus.Information = ReturnedLength;    } __finally {        if (Irp) {            if (PagingIoResourceAcquired) {                ExReleaseResourceLite(&Fcb->PagingIoResource);            }            if (MainResourceAcquired) {                ExReleaseResourceLite(&Fcb->MainResource);            }        }        if (!OpPostIrp && !IrpContext->ExceptionInProgress) {            if (Irp) {                if ( Status == STATUS_PENDING ||                     Status == STATUS_CANT_WAIT) {                    Status = Ext2LockUserBuffer(                                 IrpContext->Irp,                                 Length,                                 IoWriteAccess );                    if (NT_SUCCESS(Status)) {                        Status = Ext2QueueRequest(IrpContext);                    } else {                        Ext2CompleteIrpContext(IrpContext, Status);                    }                } else {                    if (NT_SUCCESS(Status)) {                        if (!PagingIo) {                            if (SynchronousIo) {                                FileObject->CurrentByteOffset.QuadPart =                                    ByteOffset.QuadPart + Irp->IoStatus.Information;                            }                            FileObject->Flags |= FO_FILE_FAST_IO_READ;                        }                    }                    Ext2CompleteIrpContext(IrpContext, Status);                }            } else {                Ext2FreeIrpContext(IrpContext);            }        }    }    DEBUG(DL_IO, ("Ext2ReadFile: %wZ fetch at Off=%I64xh Len=%xh Paging=%xh Nocache=%xh Returned=%xh Status=%xh/n",                  &Fcb->Mcb->ShortName, ByteOffset.QuadPart, Length, PagingIo, Nocache, ReturnedLength, Status));    return Status;}

//.........这里部分代码省略.........                IoGetRequestorProcess(Irp),                NULL  );            //            // If there are no byte range locks owned by other processes on the            // file the fast I/O read/write functions doesn't have to check for            // locks so we set IsFastIoPossible to FastIoIsPossible again.            //            if (!FsRtlGetNextFileLock(&Fcb->FileLockAnchor, TRUE)) {                if (Fcb->Header.IsFastIoPossible != FastIoIsPossible) {                    RfsdPrint((                        DBG_INFO, ": %-16.16s %-31s %s/n",                        RfsdGetCurrentProcessName(),                        "FastIoIsPossible",                        Fcb->AnsiFileName.Buffer                        ));                    Fcb->Header.IsFastIoPossible = FastIoIsPossible;                }            }        }        if ( IsFlagOn( FileObject->Flags, FO_CACHE_SUPPORTED) &&             (Fcb->NonCachedOpenCount != 0) &&             (Fcb->NonCachedOpenCount == Fcb->ReferenceCount) &&             (Fcb->SectionObject.DataSectionObject != NULL)) {            if( !IsFlagOn(Vcb->Flags, VCB_READ_ONLY) &&                !IsFlagOn(Vcb->Flags, VCB_WRITE_PROTECTED)) {                CcFlushCache(&Fcb->SectionObject, NULL, 0, NULL);            }            ExAcquireResourceExclusiveLite(&(Fcb->PagingIoResource), TRUE);            ExReleaseResourceLite(&(Fcb->PagingIoResource));            CcPurgeCacheSection( &Fcb->SectionObject,                                 NULL,                                 0,                                 FALSE );        }        if (Fcb->OpenHandleCount == 0) {            if (IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING)) {                //                //  Have to delete this file...                //#ifdef _MSC_VER#pragma prefast( suppress: 28137, "by design" )#endif                if (!ExAcquireResourceExclusiveLite(                         &Fcb->PagingIoResource,                         IrpContext->IsSynchronous                         )) {                    Status = STATUS_PENDING;                    _SEH2_LEAVE;                }                FcbPagingIoAcquired = TRUE;DbgBreak();#if DISABLED                Status = RfsdDeleteFile(IrpContext, Vcb, Fcb);                if (NT_SUCCESS(Status)) {                    if (IsDirectory(Fcb)) {

NTSTATUSRegisterPendingIrpMain(__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp,                       __in ULONG SerialNumber, __in PIRP_LIST IrpList,                       __in ULONG Flags, __in ULONG CheckMount) {  PIRP_ENTRY irpEntry;  PIO_STACK_LOCATION irpSp;  KIRQL oldIrql;  PDokanVCB vcb = NULL;  DDbgPrint("==> DokanRegisterPendingIrpMain/n");  if (GetIdentifierType(DeviceObject->DeviceExtension) == VCB) {    vcb = DeviceObject->DeviceExtension;    if (CheckMount && IsUnmountPendingVcb(vcb)) {      DDbgPrint(" device is not mounted/n");      return STATUS_NO_SUCH_DEVICE;    }  }  irpSp = IoGetCurrentIrpStackLocation(Irp);  // Allocate a record and save all the event context.  irpEntry = DokanAllocateIrpEntry();  if (NULL == irpEntry) {    DDbgPrint("  can't allocate IRP_ENTRY/n");    return STATUS_INSUFFICIENT_RESOURCES;  }  RtlZeroMemory(irpEntry, sizeof(IRP_ENTRY));  InitializeListHead(&irpEntry->ListEntry);  irpEntry->SerialNumber = SerialNumber;  irpEntry->FileObject = irpSp->FileObject;  irpEntry->Irp = Irp;  irpEntry->IrpSp = irpSp;  irpEntry->IrpList = IrpList;  irpEntry->Flags = Flags;  // Update the irp timeout for the entry  if (vcb) {    ExAcquireResourceExclusiveLite(&vcb->Dcb->Resource, TRUE);    DokanUpdateTimeout(&irpEntry->TickCount, vcb->Dcb->IrpTimeout);    ExReleaseResourceLite(&vcb->Dcb->Resource);  } else {    DokanUpdateTimeout(&irpEntry->TickCount, DOKAN_IRP_PENDING_TIMEOUT);  }  // DDbgPrint("  Lock IrpList.ListLock/n");  ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);  KeAcquireSpinLock(&IrpList->ListLock, &oldIrql);  IoSetCancelRoutine(Irp, DokanIrpCancelRoutine);  if (Irp->Cancel) {    if (IoSetCancelRoutine(Irp, NULL) != NULL) {      // DDbgPrint("  Release IrpList.ListLock %d/n", __LINE__);      KeReleaseSpinLock(&IrpList->ListLock, oldIrql);      DokanFreeIrpEntry(irpEntry);      return STATUS_CANCELLED;    }  }  IoMarkIrpPending(Irp);  InsertTailList(&IrpList->ListHead, &irpEntry->ListEntry);  irpEntry->CancelRoutineFreeMemory = FALSE;  // save the pointer in order to be accessed by cancel routine  Irp->Tail.Overlay.DriverContext[DRIVER_CONTEXT_IRP_ENTRY] = irpEntry;  KeSetEvent(&IrpList->NotEmpty, IO_NO_INCREMENT, FALSE);  // DDbgPrint("  Release IrpList.ListLock/n");  KeReleaseSpinLock(&IrpList->ListLock, oldIrql);  DDbgPrint("<== DokanRegisterPendingIrpMain/n");  return STATUS_PENDING;}

//.........这里部分代码省略.........    DDbgPrint("  Mounting on current session only/n");    mountGlobally = FALSE;  }  if (eventStart->Flags & DOKAN_EVENT_FILELOCK_USER_MODE) {    DDbgPrint("  FileLock in User Mode/n");    fileLockUserMode = TRUE;  }  KeEnterCriticalRegion();  ExAcquireResourceExclusiveLite(&dokanGlobal->Resource, TRUE);  DOKAN_CONTROL dokanControl;  RtlZeroMemory(&dokanControl, sizeof(dokanControl));  RtlStringCchCopyW(dokanControl.MountPoint, MAXIMUM_FILENAME_LENGTH,                    L"//DosDevices//");  if (wcslen(eventStart->MountPoint) == 1) {    dokanControl.MountPoint[12] = towupper(eventStart->MountPoint[0]);    dokanControl.MountPoint[13] = L':';    dokanControl.MountPoint[14] = L'/0';  } else {    RtlStringCchCatW(dokanControl.MountPoint, MAXIMUM_FILENAME_LENGTH,                     eventStart->MountPoint);  }  DDbgPrint("  Checking for MountPoint %ls /n", dokanControl.MountPoint);  PMOUNT_ENTRY foundEntry = FindMountEntry(dokanGlobal, &dokanControl, FALSE);  if (foundEntry != NULL) {    DDbgPrint("  MountPoint exists already %ls /n", dokanControl.MountPoint);    driverInfo->DriverVersion = DOKAN_DRIVER_VERSION;    driverInfo->Status = DOKAN_START_FAILED;    Irp->IoStatus.Status = STATUS_SUCCESS;    Irp->IoStatus.Information = sizeof(EVENT_DRIVER_INFO);    ExReleaseResourceLite(&dokanGlobal->Resource);    KeLeaveCriticalRegion();    ExFreePool(eventStart);    ExFreePool(baseGuidString);    return STATUS_SUCCESS;  }  baseGuid.Data2 = (USHORT)(dokanGlobal->MountId & 0xFFFF) ^ baseGuid.Data2;  baseGuid.Data3 = (USHORT)(dokanGlobal->MountId >> 16) ^ baseGuid.Data3;  status = RtlStringFromGUID(&baseGuid, &unicodeGuid);  if (!NT_SUCCESS(status)) {    ExReleaseResourceLite(&dokanGlobal->Resource);    KeLeaveCriticalRegion();    ExFreePool(eventStart);    ExFreePool(baseGuidString);    return status;  }  RtlZeroMemory(baseGuidString, 64 * sizeof(WCHAR));  RtlStringCchCopyW(baseGuidString, 64,                    unicodeGuid.Buffer);  RtlFreeUnicodeString(&unicodeGuid);  InterlockedIncrement((LONG *)&dokanGlobal->MountId);  status = DokanCreateDiskDevice(      DeviceObject->DriverObject, dokanGlobal->MountId, eventStart->MountPoint,      eventStart->UNCName, baseGuidString, dokanGlobal, deviceType,      deviceCharacteristics, mountGlobally, useMountManager, &dcb);  if (!NT_SUCCESS(status)) {    ExReleaseResourceLite(&dokanGlobal->Resource);    KeLeaveCriticalRegion();

//.........这里部分代码省略.........               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));        ASSERT(IsMounted(Vcb));        if ( IsFlagOn(Vcb->Flags, VCB_READ_ONLY) ||                IsFlagOn(Vcb->Flags, VCB_WRITE_PROTECTED)) {            Status =  STATUS_SUCCESS;            __leave;        }        Irp = IrpContext->Irp;        IrpSp = IoGetCurrentIrpStackLocation(Irp);        FileObject = IrpContext->FileObject;        FcbOrVcb = (PEXT2_FCBVCB) FileObject->FsContext;        ASSERT(FcbOrVcb != NULL);        Ccb = (PEXT2_CCB) FileObject->FsContext2;        if (Ccb == NULL) {            Status =  STATUS_SUCCESS;            __leave;        }        MainResourceAcquired =            ExAcquireResourceExclusiveLite(&FcbOrVcb->MainResource,                                           IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));        ASSERT(MainResourceAcquired);        DEBUG(DL_INF, ("Ext2Flush-pre:  total mcb records=%u/n",                       FsRtlNumberOfRunsInLargeMcb(&Vcb->Extents)));        if (FcbOrVcb->Identifier.Type == EXT2VCB) {            Ext2VerifyVcb(IrpContext, Vcb);            Status = Ext2FlushFiles(IrpContext, (PEXT2_VCB)(FcbOrVcb), FALSE);            if (NT_SUCCESS(Status)) {                __leave;            }            Status = Ext2FlushVolume(IrpContext, (PEXT2_VCB)(FcbOrVcb), FALSE);            if (NT_SUCCESS(Status) && IsFlagOn(Vcb->Volume->Flags, FO_FILE_MODIFIED)) {                ClearFlag(Vcb->Volume->Flags, FO_FILE_MODIFIED);            }        } else if (FcbOrVcb->Identifier.Type == EXT2FCB) {            Fcb = (PEXT2_FCB)(FcbOrVcb);            Status = Ext2FlushFile(IrpContext, Fcb, Ccb);            if (NT_SUCCESS(Status)) {                if (IsFlagOn(FileObject->Flags, FO_FILE_MODIFIED)) {                    Fcb->Mcb->FileAttr |= FILE_ATTRIBUTE_ARCHIVE;                    ClearFlag(FileObject->Flags, FO_FILE_MODIFIED);                }            }        }        DEBUG(DL_INF, ("Ext2Flush-post: total mcb records=%u/n",                       FsRtlNumberOfRunsInLargeMcb(&Vcb->Extents)));    } __finally {        if (MainResourceAcquired) {            ExReleaseResourceLite(&FcbOrVcb->MainResource);        }        if (!IrpContext->ExceptionInProgress) {            if (Vcb && Irp && IrpSp && (!IsFlagOn(Vcb->Flags, VCB_READ_ONLY))) {                // Call the disk driver to flush the physial media.                NTSTATUS DriverStatus;                PIO_STACK_LOCATION NextIrpSp;                NextIrpSp = IoGetNextIrpStackLocation(Irp);                *NextIrpSp = *IrpSp;                IoSetCompletionRoutine( Irp,                                        Ext2FlushCompletionRoutine,                                        NULL,                                        TRUE,                                        TRUE,                                        TRUE );                DriverStatus = IoCallDriver(Vcb->TargetDeviceObject, Irp);                Status = (DriverStatus == STATUS_INVALID_DEVICE_REQUEST) ?                         Status : DriverStatus;                IrpContext->Irp = Irp = NULL;            }            Ext2CompleteIrpContext(IrpContext, Status);        }    }    return Status;}

VOID MrUnlockGlobal(){    ExReleaseResourceLite(&g_core.mc_lock);    KeLeaveCriticalRegion();}

//.........这里部分代码省略.........    This is a call back routine for doing the fast unlock all by key call.Arguments:    FileObject - Supplies the file object used in this operation    ProcessId - Supplies the process ID used in this operation    Key - Supplies the key used in this operation    Status - Receives the Status if this operation is successfulReturn Value:    BOOLEAN - TRUE if this operation completed and FALSE if caller        needs to take the long route.--*/{    BOOLEAN Results;    PVCB Vcb;    PFCB Fcb;    PCCB Ccb;    DebugTrace(+1, Dbg, "FatFastUnlockAllByKey/n", 0);    IoStatus->Information = 0;    //    //  Decode the type of file object we're being asked to process and make sure    //  it is only a user file open.    //    if (FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb ) != UserFileOpen) {        IoStatus->Status = STATUS_INVALID_PARAMETER;        DebugTrace(-1, Dbg, "FatFastUnlockAll -> TRUE (STATUS_INVALID_PARAMETER)/n", 0);        return TRUE;    }    //    //  Acquire exclusive access to the Fcb this operation can always wait    //    FsRtlEnterFileSystem();    (VOID) ExAcquireResourceSharedLite( Fcb->Header.Resource, TRUE );    try {        //        //  We check whether we can proceed based on the state of the file oplocks.        //        if (!FsRtlOplockIsFastIoPossible( &(Fcb)->Specific.Fcb.Oplock )) {            try_return( Results = FALSE );        }        //        //  Now call the FsRtl routine to do the actual processing of the        //  Lock request.  The call will always succeed.        //        Results = TRUE;        IoStatus->Status = FsRtlFastUnlockAllByKey( &Fcb->Specific.Fcb.FileLock,                           FileObject,                           ProcessId,                           Key,                           NULL );        //        //  Set the flag indicating if Fast I/O is possible        //        Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );try_exit:        NOTHING;    }    finally {        DebugUnwind( FatFastUnlockAllByKey );        //        //  Release the Fcb, and return to our caller        //        ExReleaseResourceLite( (Fcb)->Header.Resource );        FsRtlExitFileSystem();        DebugTrace(-1, Dbg, "FatFastUnlockAllByKey -> %08lx/n", Results);    }    return Results;}

//.........这里部分代码省略.........        __leave;      }    }    ccb = fileObject->FsContext2;    ASSERT(ccb != NULL);    fcb = ccb->Fcb;    ASSERT(fcb != NULL);    if (DokanFCBFlagsIsSet(fcb, DOKAN_FILE_DIRECTORY)) {      DDbgPrint("   DOKAN_FILE_DIRECTORY %p/n", fcb);      status = STATUS_INVALID_PARAMETER;      __leave;    }    if (Irp->Flags & IRP_PAGING_IO) {      isPagingIo = TRUE;    }    if (fileObject->Flags & FO_SYNCHRONOUS_IO) {      isSynchronousIo = TRUE;    }    if (Irp->Flags & IRP_NOCACHE) {      noCache = TRUE;    }    if (!isPagingIo && (fileObject->SectionObjectPointer != NULL) &&        (fileObject->SectionObjectPointer->DataSectionObject != NULL)) {      ExAcquireResourceExclusiveLite(&fcb->PagingIoResource, TRUE);      CcFlushCache(&fcb->SectionObjectPointers,                   &irpSp->Parameters.Read.ByteOffset,                   irpSp->Parameters.Read.Length, NULL);      ExReleaseResourceLite(&fcb->PagingIoResource);    }    DokanFCBLockRO(fcb);    fcbLocked = TRUE;    // length of EventContext is sum of file name length and itself    eventLength = sizeof(EVENT_CONTEXT) + fcb->FileName.Length;    eventContext = AllocateEventContext(vcb->Dcb, Irp, eventLength, ccb);    if (eventContext == NULL) {      status = STATUS_INSUFFICIENT_RESOURCES;      __leave;    }    eventContext->Context = ccb->UserContext;    // DDbgPrint("   get Context %X/n", (ULONG)ccb->UserContext);    if (isPagingIo) {      DDbgPrint("  Paging IO/n");      eventContext->FileFlags |= DOKAN_PAGING_IO;    }    if (isSynchronousIo) {      DDbgPrint("  Synchronous IO/n");      eventContext->FileFlags |= DOKAN_SYNCHRONOUS_IO;    }    if (noCache) {      DDbgPrint("  Nocache/n");      eventContext->FileFlags |= DOKAN_NOCACHE;    }    // offset of file to read    eventContext->Operation.Read.ByteOffset = byteOffset;

NTSTATUSDokanDispatchSetInformation(__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp) {  NTSTATUS status = STATUS_NOT_IMPLEMENTED;  PIO_STACK_LOCATION irpSp;  PVOID buffer;  PFILE_OBJECT fileObject;  PDokanCCB ccb;  PDokanFCB fcb = NULL;  PDokanVCB vcb;  ULONG eventLength;  PFILE_OBJECT targetFileObject;  PEVENT_CONTEXT eventContext;  BOOLEAN isPagingIo = FALSE;  BOOLEAN fcbLocked = FALSE;  PFILE_END_OF_FILE_INFORMATION pInfoEoF = NULL;  vcb = DeviceObject->DeviceExtension;  __try {    DDbgPrint("==> DokanSetInformationn/n");    irpSp = IoGetCurrentIrpStackLocation(Irp);    fileObject = irpSp->FileObject;    if (fileObject == NULL) {      DDbgPrint("  fileObject == NULL/n");      status = STATUS_INVALID_PARAMETER;      __leave;    }    if (GetIdentifierType(vcb) != VCB ||        !DokanCheckCCB(vcb->Dcb, fileObject->FsContext2)) {      status = STATUS_INVALID_PARAMETER;      __leave;    }    ccb = (PDokanCCB)fileObject->FsContext2;    ASSERT(ccb != NULL);    DDbgPrint("  ProcessId %lu/n", IoGetRequestorProcessId(Irp));    DokanPrintFileName(fileObject);    buffer = Irp->AssociatedIrp.SystemBuffer;    if (Irp->Flags & IRP_PAGING_IO) {      isPagingIo = TRUE;    }    fcb = ccb->Fcb;    ASSERT(fcb != NULL);    switch (irpSp->Parameters.SetFile.FileInformationClass) {    case FileAllocationInformation:      DDbgPrint(          "  FileAllocationInformation %lld/n",          ((PFILE_ALLOCATION_INFORMATION)buffer)->AllocationSize.QuadPart);      break;    case FileBasicInformation:      DDbgPrint("  FileBasicInformation/n");      break;    case FileDispositionInformation:      DDbgPrint("  FileDispositionInformation/n");      break;    case FileEndOfFileInformation:      if ((fileObject->SectionObjectPointer != NULL) &&          (fileObject->SectionObjectPointer->DataSectionObject != NULL)) {        pInfoEoF = (PFILE_END_OF_FILE_INFORMATION)buffer;        if (!MmCanFileBeTruncated(fileObject->SectionObjectPointer,                                  &pInfoEoF->EndOfFile)) {          status = STATUS_USER_MAPPED_FILE;          __leave;        }        if (!isPagingIo) {          ExAcquireResourceExclusiveLite(&fcb->PagingIoResource, TRUE);          CcFlushCache(&fcb->SectionObjectPointers, NULL, 0, NULL);          CcPurgeCacheSection(&fcb->SectionObjectPointers, NULL, 0, FALSE);          ExReleaseResourceLite(&fcb->PagingIoResource);        }      }      DDbgPrint("  FileEndOfFileInformation %lld/n",                ((PFILE_END_OF_FILE_INFORMATION)buffer)->EndOfFile.QuadPart);      break;    case FileLinkInformation:      DDbgPrint("  FileLinkInformation/n");      break;    case FilePositionInformation: {      PFILE_POSITION_INFORMATION posInfo;      posInfo = (PFILE_POSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;      ASSERT(posInfo != NULL);      DDbgPrint("  FilePositionInformation %lld/n",                posInfo->CurrentByteOffset.QuadPart);      fileObject->CurrentByteOffset = posInfo->CurrentByteOffset;      status = STATUS_SUCCESS;//.........这里部分代码省略.........

static NTSTATUSVfatGetRetrievalPointers(PVFAT_IRP_CONTEXT IrpContext){   PIO_STACK_LOCATION Stack;   LARGE_INTEGER Vcn;   PRETRIEVAL_POINTERS_BUFFER RetrievalPointers;   PFILE_OBJECT FileObject;   ULONG MaxExtentCount;   PVFATFCB Fcb;   PDEVICE_EXTENSION DeviceExt;   ULONG FirstCluster;   ULONG CurrentCluster;   ULONG LastCluster;   NTSTATUS Status;   DPRINT("VfatGetRetrievalPointers(IrpContext %p)/n", IrpContext);   DeviceExt = IrpContext->DeviceExt;   FileObject = IrpContext->FileObject;   Stack = IrpContext->Stack;   if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STARTING_VCN_INPUT_BUFFER) ||       Stack->Parameters.DeviceIoControl.Type3InputBuffer == NULL)   {      return STATUS_INVALID_PARAMETER;   }   if (IrpContext->Irp->UserBuffer == NULL ||       Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(RETRIEVAL_POINTERS_BUFFER))   {      return STATUS_BUFFER_TOO_SMALL;   }   Fcb = FileObject->FsContext;   ExAcquireResourceSharedLite(&Fcb->MainResource, TRUE);   Vcn = ((PSTARTING_VCN_INPUT_BUFFER)Stack->Parameters.DeviceIoControl.Type3InputBuffer)->StartingVcn;   RetrievalPointers = IrpContext->Irp->UserBuffer;   MaxExtentCount = ((Stack->Parameters.DeviceIoControl.OutputBufferLength - sizeof(RetrievalPointers->ExtentCount) - sizeof(RetrievalPointers->StartingVcn)) / sizeof(RetrievalPointers->Extents[0]));   if (Vcn.QuadPart >= Fcb->RFCB.AllocationSize.QuadPart / DeviceExt->FatInfo.BytesPerCluster)   {      Status = STATUS_INVALID_PARAMETER;      goto ByeBye;   }   CurrentCluster = FirstCluster = vfatDirEntryGetFirstCluster(DeviceExt, &Fcb->entry);   Status = OffsetToCluster(DeviceExt, FirstCluster,                            Vcn.u.LowPart * DeviceExt->FatInfo.BytesPerCluster,                            &CurrentCluster, FALSE);   if (!NT_SUCCESS(Status))   {      goto ByeBye;   }   RetrievalPointers->StartingVcn = Vcn;   RetrievalPointers->ExtentCount = 0;   RetrievalPointers->Extents[0].Lcn.u.HighPart = 0;   RetrievalPointers->Extents[0].Lcn.u.LowPart = CurrentCluster - 2;   LastCluster = 0;   while (CurrentCluster != 0xffffffff && RetrievalPointers->ExtentCount < MaxExtentCount)   {      LastCluster = CurrentCluster;      Status = NextCluster(DeviceExt, CurrentCluster, &CurrentCluster, FALSE);      Vcn.QuadPart++;      if (!NT_SUCCESS(Status))      {         goto ByeBye;      }      if (LastCluster + 1 != CurrentCluster)      {         RetrievalPointers->Extents[RetrievalPointers->ExtentCount].NextVcn = Vcn;         RetrievalPointers->ExtentCount++;         if (RetrievalPointers->ExtentCount < MaxExtentCount)         {            RetrievalPointers->Extents[RetrievalPointers->ExtentCount].Lcn.u.HighPart = 0;            RetrievalPointers->Extents[RetrievalPointers->ExtentCount].Lcn.u.LowPart = CurrentCluster - 2;         }      }   }   IrpContext->Irp->IoStatus.Information = sizeof(RETRIEVAL_POINTERS_BUFFER) + (sizeof(RetrievalPointers->Extents[0]) * (RetrievalPointers->ExtentCount - 1));   Status = STATUS_SUCCESS;ByeBye:   ExReleaseResourceLite(&Fcb->MainResource);   return Status;}

NTSTATUS GenerateFileName(IN PFLT_INSTANCE  Instance,    IN PFILE_OBJECT  FileObject,    IN PFLT_CALLBACK_DATA  CallbackData,    IN FLT_FILE_NAME_OPTIONS  NameOptions,    OUT PBOOLEAN  CacheFileNameInformation,    OUT PFLT_NAME_CONTROL  FileName) //上层的minifilter过滤驱动的名字请求进行处理{	NTSTATUS Status = STATUS_UNSUCCESSFUL;	PFILE_OBJECT StreamObject = FileObject;	PFLT_FILE_NAME_INFORMATION FileNameInformation = NULL;	BOOLEAN bEncryptResource = FALSE;	PFCB Fcb = FileObject->FsContext;	PCCB Ccb = FileObject->FsContext2;	FsRtlEnterFileSystem();	try	{		if(IsMyFakeFcb(FileObject))		{						ExAcquireResourceSharedLite(Fcb->EncryptResource,TRUE);			bEncryptResource = TRUE;			if(BooleanFlagOn(Fcb->FcbState,SCB_STATE_SHADOW_CLOSE) || Ccb->StreamFileInfo.StreamObject == NULL)			{				try_return (Status = STATUS_FILE_DELETED);			}			else			{							StreamObject = Ccb->StreamFileInfo.StreamObject;			}		}		ClearFlag(NameOptions,FLT_FILE_NAME_REQUEST_FROM_CURRENT_PROVIDER);		if(FlagOn(NameOptions,FLT_FILE_NAME_NORMALIZED))		{			ClearFlag(NameOptions,FLT_FILE_NAME_NORMALIZED);			SetFlag(NameOptions,FLT_FILE_NAME_OPENED);		}				if (CallbackData) 		{			PFILE_OBJECT TemFileObject = CallbackData->Iopb->TargetFileObject;			CallbackData->Iopb->TargetFileObject = StreamObject;			FltSetCallbackDataDirty(CallbackData);			Status = FltGetFileNameInformation(CallbackData,NameOptions, &FileNameInformation);						CallbackData->Iopb->TargetFileObject = TemFileObject;			FltClearCallbackDataDirty(CallbackData);		} 		else 		{			Status = FltGetFileNameInformationUnsafe(StreamObject,Instance, NameOptions, &FileNameInformation);		}		if(!NT_SUCCESS(Status))		{			try_return (Status);		}		Status = FltCheckAndGrowNameControl(FileName, FileNameInformation->Name.Length);		if(!NT_SUCCESS(Status))		{			try_return (Status);		}		RtlCopyUnicodeString(&FileName->Name, &FileNameInformation->Name);		if(FileNameInformation != NULL)		{			FltReleaseFileNameInformation(FileNameInformation);		}		Status = STATUS_SUCCESS;try_exit: NOTHING;	}	finally	{		if(bEncryptResource)		{			ExReleaseResourceLite( Fcb->EncryptResource );		}	}	FsRtlExitFileSystem();	return Status;}

/* * FUNCTION: Retrieve the specified volume information */NTSTATUSVfatQueryVolumeInformation(    PVFAT_IRP_CONTEXT IrpContext){    FS_INFORMATION_CLASS FsInformationClass;    NTSTATUS RC = STATUS_SUCCESS;    PVOID SystemBuffer;    ULONG BufferLength;    /* PRECONDITION */    ASSERT(IrpContext);    DPRINT("VfatQueryVolumeInformation(IrpContext %p)/n", IrpContext);    if (!ExAcquireResourceSharedLite(&((PDEVICE_EXTENSION)IrpContext->DeviceObject->DeviceExtension)->DirResource,                                     BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT)))    {        DPRINT1("DirResource failed!/n");        return VfatMarkIrpContextForQueue(IrpContext);    }    /* INITIALIZATION */    FsInformationClass = IrpContext->Stack->Parameters.QueryVolume.FsInformationClass;    BufferLength = IrpContext->Stack->Parameters.QueryVolume.Length;    SystemBuffer = IrpContext->Irp->AssociatedIrp.SystemBuffer;    DPRINT("FsInformationClass %d/n", FsInformationClass);    DPRINT("SystemBuffer %p/n", SystemBuffer);    switch (FsInformationClass)    {        case FileFsVolumeInformation:            RC = FsdGetFsVolumeInformation(IrpContext->DeviceObject,                                           SystemBuffer,                                           &BufferLength);            break;        case FileFsAttributeInformation:            RC = FsdGetFsAttributeInformation(IrpContext->DeviceObject->DeviceExtension,                                              SystemBuffer,                                              &BufferLength);            break;        case FileFsSizeInformation:            RC = FsdGetFsSizeInformation(IrpContext->DeviceObject,                                         SystemBuffer,                                         &BufferLength);            break;        case FileFsDeviceInformation:            RC = FsdGetFsDeviceInformation(IrpContext->DeviceObject,                                           SystemBuffer,                                           &BufferLength);            break;        case FileFsFullSizeInformation:            RC = FsdGetFsFullSizeInformation(IrpContext->DeviceObject,                                             SystemBuffer,                                             &BufferLength);            break;        default:            RC = STATUS_NOT_SUPPORTED;    }    ExReleaseResourceLite(&((PDEVICE_EXTENSION)IrpContext->DeviceObject->DeviceExtension)->DirResource);    IrpContext->Irp->IoStatus.Information =        IrpContext->Stack->Parameters.QueryVolume.Length - BufferLength;    return RC;}

//.........这里部分代码省略.........      DDbgPrint("  buffer == NULL/n");      status = STATUS_INVALID_PARAMETER;      __leave;    }    if (irpSp->Parameters.Write.ByteOffset.LowPart ==            FILE_WRITE_TO_END_OF_FILE &&        irpSp->Parameters.Write.ByteOffset.HighPart == -1) {      writeToEoF = TRUE;    }    if (Irp->Flags & IRP_PAGING_IO) {      isPagingIo = TRUE;    }    if (Irp->Flags & IRP_NOCACHE) {      isNonCached = TRUE;    }    if (fileObject->Flags & FO_SYNCHRONOUS_IO) {      isSynchronousIo = TRUE;    }    if (!isPagingIo && (fileObject->SectionObjectPointer != NULL) &&        (fileObject->SectionObjectPointer->DataSectionObject != NULL)) {      ExAcquireResourceExclusiveLite(&fcb->PagingIoResource, TRUE);      CcFlushCache(&fcb->SectionObjectPointers,                   writeToEoF ? NULL : &irpSp->Parameters.Write.ByteOffset,                   irpSp->Parameters.Write.Length, NULL);      CcPurgeCacheSection(&fcb->SectionObjectPointers,                          writeToEoF ? NULL                                     : &irpSp->Parameters.Write.ByteOffset,                          irpSp->Parameters.Write.Length, FALSE);      ExReleaseResourceLite(&fcb->PagingIoResource);    }    // Cannot write at end of the file when using paging IO    if (writeToEoF && isPagingIo) {      DDbgPrint("  writeToEoF & isPagingIo/n");      Irp->IoStatus.Information = 0;      status = STATUS_SUCCESS;      __leave;    }    // the length of EventContext is sum of length to write and length of file    // name    DokanFCBLockRO(fcb);    fcbLocked = TRUE;    eventLength = sizeof(EVENT_CONTEXT) + irpSp->Parameters.Write.Length +                  fcb->FileName.Length;    eventContext = AllocateEventContext(vcb->Dcb, Irp, eventLength, ccb);    // no more memory!    if (eventContext == NULL) {      status = STATUS_INSUFFICIENT_RESOURCES;      __leave;    }    eventContext->Context = ccb->UserContext;    // DDbgPrint("   get Context %X/n", (ULONG)ccb->UserContext);    // When the length is bigger than usual event notitfication buffer,    // saves pointer in DiverContext to copy EventContext after allocating    // more bigger memory.    Irp->Tail.Overlay.DriverContext[DRIVER_CONTEXT_EVENT] = eventContext;

VOIDFatFspClose (    IN PVCB Vcb OPTIONAL    )/*++Routine Description:    This routine implements the FSP part of Close.Arguments:    Vcb - If present, tells us to only close file objects opened on the        specified volume.Return Value:    None.--*/{    PCLOSE_CONTEXT CloseContext;    PVCB CurrentVcb = NULL;    PVCB LastVcb = NULL;    BOOLEAN FreeContext = FALSE;    BOOLEAN TopLevel = FALSE;    ULONG LoopsWithVcbHeld = 0;    PAGED_CODE();    DebugTrace(+1, Dbg, "FatFspClose/n", 0);    //    //  Set the top level IRP for the true FSP operation.    //        if (!ARGUMENT_PRESENT( Vcb )) {                IoSetTopLevelIrp( (PIRP)FSRTL_FSP_TOP_LEVEL_IRP );        TopLevel = TRUE;    }    while ((CloseContext = FatRemoveClose(Vcb, LastVcb)) != NULL) {        //        //  If we are in the FSP (i.e. Vcb == NULL), then try to keep ahead of        //  creates by doing several closes with one acquisition of the Vcb.        //        //  Note that we cannot be holding the Vcb on entry to FatCommonClose        //  if this is last close as we will try to acquire FatData, and        //  worse the volume (and therefore the Vcb) may go away.        //        if (!ARGUMENT_PRESENT(Vcb)) {                         if (!FatData.ShutdownStarted) {                if (CloseContext->Vcb != CurrentVcb) {                    LoopsWithVcbHeld = 0;                    //                    //  Release a previously held Vcb, if any.                    //                    if (CurrentVcb != NULL) {                        ExReleaseResourceLite( &CurrentVcb->Resource);                    }                    //                    //  Get the new Vcb.                    //                    CurrentVcb = CloseContext->Vcb;                    (VOID)ExAcquireResourceExclusiveLite( &CurrentVcb->Resource, TRUE );                } else {                    //                    //  Share the resource occasionally if we seem to be finding a lot                    //  of closes for a single volume.                    //                    if (++LoopsWithVcbHeld >= 20) {                        if (ExGetSharedWaiterCount( &CurrentVcb->Resource ) +                            ExGetExclusiveWaiterCount( &CurrentVcb->Resource )) {                            ExReleaseResourceLite( &CurrentVcb->Resource);                            (VOID)ExAcquireResourceExclusiveLite( &CurrentVcb->Resource, TRUE );                        }                        LoopsWithVcbHeld = 0;                    }                }//.........这里部分代码省略.........

//.........这里部分代码省略.........	if (!(FlagOn(IrpContext.NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT) ?  		  ExAcquireResourceExclusiveLite( &Vcb->SecondaryResource, Wait ) : ExAcquireResourceExclusiveLite( &Vcb->Resource, Wait ))) {		if (volDoResourceAcquired) {			ASSERT( ExIsResourceAcquiredSharedLite(&volDo->Resource) );			SecondaryReleaseResourceLite( NULL, &volDo->Resource );		}        return STATUS_PENDING;    }#else    if (!ExAcquireResourceExclusiveLite( &Vcb->Resource, Wait )) {        return STATUS_PENDING;    }#endif    //    //  The following test makes sure that we don't blow away an Fcb if we    //  are trying to do a Supersede/Overwrite open above us.  This test    //  does not apply for the EA file.    //    if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_CREATE_IN_PROGRESS) &&        Vcb->EaFcb != Fcb) {#if __NDAS_FAT_SECONDARY__	 	if (FlagOn(IrpContext.NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT))  			ExReleaseResourceLite( &Vcb->SecondaryResource );		else			ExReleaseResourceLite( &Vcb->Resource );		if (volDoResourceAcquired) {			ASSERT( ExIsResourceAcquiredSharedLite(&volDo->Resource) );			SecondaryReleaseResourceLite( NULL, &volDo->Resource );		}#else        ExReleaseResourceLite( &Vcb->Resource );#endif        return STATUS_PENDING;    }    //    //  Setting the following flag prevents recursive closes of directory file    //  objects, which are handled in a special case loop.    //    if ( FlagOn(Vcb->VcbState, VCB_STATE_FLAG_CLOSE_IN_PROGRESS) ) {        RecursiveClose = TRUE;    } else {        SetFlag(Vcb->VcbState, VCB_STATE_FLAG_CLOSE_IN_PROGRESS);        RecursiveClose = FALSE;        //        //  Since we are at the top of the close chain, we need to add