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

NTSTATUSVfatFlush(    PVFAT_IRP_CONTEXT IrpContext){    NTSTATUS Status;    PVFATFCB Fcb;    /* This request is not allowed on the main device object. */    if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)    {        IrpContext->Irp->IoStatus.Information = 0;        return STATUS_INVALID_DEVICE_REQUEST;    }    Fcb = (PVFATFCB)IrpContext->FileObject->FsContext;    ASSERT(Fcb);    if (BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME))    {        ExAcquireResourceExclusiveLite(&IrpContext->DeviceExt->DirResource, TRUE);        Status = VfatFlushVolume(IrpContext->DeviceExt, Fcb);        ExReleaseResourceLite(&IrpContext->DeviceExt->DirResource);    }    else    {        ExAcquireResourceExclusiveLite(&Fcb->MainResource, TRUE);        Status = VfatFlushFile(IrpContext->DeviceExt, Fcb);        ExReleaseResourceLite (&Fcb->MainResource);    }    IrpContext->Irp->IoStatus.Information = 0;    return Status;}

staticVOIDTestResourceExclusiveAccess(    IN PERESOURCE Res){    LONG Count = 0;    KeEnterCriticalRegion();    ok_bool_true(ExAcquireResourceExclusiveLite(Res, FALSE), "ExAcquireResourceExclusiveLite returned"); ++Count;    CheckResourceStatus(Res, TRUE, Count, 0LU, 0LU);    ok_bool_true(ExAcquireResourceExclusiveLite(Res, TRUE), "ExAcquireResourceExclusiveLite returned"); ++Count;    CheckResourceStatus(Res, TRUE, Count, 0LU, 0LU);    ok_bool_true(ExAcquireResourceSharedLite(Res, FALSE), "ExAcquireResourceSharedLite returned"); ++Count;    ok_bool_true(ExAcquireResourceSharedLite(Res, TRUE), "ExAcquireResourceSharedLite returned"); ++Count;    ok_bool_true(ExAcquireSharedStarveExclusive(Res, FALSE), "ExAcquireSharedStarveExclusive returned"); ++Count;    ok_bool_true(ExAcquireSharedStarveExclusive(Res, TRUE), "ExAcquireSharedStarveExclusive returned"); ++Count;    ok_bool_true(ExAcquireSharedWaitForExclusive(Res, FALSE), "ExAcquireSharedWaitForExclusive returned"); ++Count;    ok_bool_true(ExAcquireSharedWaitForExclusive(Res, TRUE), "ExAcquireSharedWaitForExclusive returned"); ++Count;    CheckResourceStatus(Res, TRUE, Count, 0LU, 0LU);    ExConvertExclusiveToSharedLite(Res);    CheckResourceStatus(Res, FALSE, Count, 0LU, 0LU);    while (Count--)        ExReleaseResourceLite(Res);    KeLeaveCriticalRegion();}

BOOLEAN FspFileNodeTryAcquireExclusiveF(FSP_FILE_NODE *FileNode, ULONG Flags, BOOLEAN Wait){    PAGED_CODE();    FSP_FILE_NODE_GET_FLAGS();    FSP_FILE_NODE_ASSERT_FLAGS_CLR();    BOOLEAN Result = TRUE;    if (Flags & FspFileNodeAcquireMain)    {        Result = ExAcquireResourceExclusiveLite(FileNode->Header.Resource, Wait);        if (!Result)            return FALSE;    }    if (Flags & FspFileNodeAcquirePgio)    {        Result = ExAcquireResourceExclusiveLite(FileNode->Header.PagingIoResource, Wait);        if (!Result)        {            if (Flags & FspFileNodeAcquireMain)                ExReleaseResourceLite(FileNode->Header.Resource);            return FALSE;        }    }    if (Result)        FSP_FILE_NODE_SET_FLAGS();    return Result;}

NTSTATUSDokanEventRelease(__in PDEVICE_OBJECT DeviceObject) {  PDokanDCB dcb;  PDokanVCB vcb;  PDokanFCB fcb;  PDokanCCB ccb;  PLIST_ENTRY fcbEntry, fcbNext, fcbHead;  PLIST_ENTRY ccbEntry, ccbNext, ccbHead;  NTSTATUS status = STATUS_SUCCESS;  vcb = DeviceObject->DeviceExtension;  if (GetIdentifierType(vcb) != VCB) {    return STATUS_INVALID_PARAMETER;  }  dcb = vcb->Dcb;  // ExAcquireResourceExclusiveLite(&dcb->Resource, TRUE);  dcb->Mounted = 0;  // ExReleaseResourceLite(&dcb->Resource);  // search CCB list to complete not completed Directory Notification  KeEnterCriticalRegion();  ExAcquireResourceExclusiveLite(&vcb->Resource, TRUE);  fcbHead = &vcb->NextFCB;  for (fcbEntry = fcbHead->Flink; fcbEntry != fcbHead; fcbEntry = fcbNext) {    fcbNext = fcbEntry->Flink;    fcb = CONTAINING_RECORD(fcbEntry, DokanFCB, NextFCB);    ExAcquireResourceExclusiveLite(&fcb->Resource, TRUE);    ccbHead = &fcb->NextCCB;    for (ccbEntry = ccbHead->Flink; ccbEntry != ccbHead; ccbEntry = ccbNext) {      ccbNext = ccbEntry->Flink;      ccb = CONTAINING_RECORD(ccbEntry, DokanCCB, NextCCB);      DDbgPrint("  NotifyCleanup ccb:%p, context:%X, filename:%wZ/n", ccb,                (ULONG)ccb->UserContext, &fcb->FileName);      FsRtlNotifyCleanup(vcb->NotifySync, &vcb->DirNotifyList, ccb);    }    ExReleaseResourceLite(&fcb->Resource);  }  ExReleaseResourceLite(&vcb->Resource);  KeLeaveCriticalRegion();  ReleasePendingIrp(&dcb->PendingIrp);  ReleasePendingIrp(&dcb->PendingEvent);  DokanStopCheckThread(dcb);  DokanStopEventNotificationThread(dcb);  DokanDeleteDeviceObject(dcb);  return status;}

NTSTATUSDokanFreeFCB(  __in PDokanFCB Fcb  ){	PDokanVCB vcb;	ASSERT(Fcb != NULL);	vcb = Fcb->Vcb;	KeEnterCriticalRegion();	ExAcquireResourceExclusiveLite(&vcb->Resource, TRUE);	ExAcquireResourceExclusiveLite(&Fcb->Resource, TRUE);	InterlockedDecrement(&Fcb->FileCount);	if (Fcb->FileCount == 0) {		RemoveEntryList(&Fcb->NextFCB);		DDbgPrint("  Free FCB:%p/n", Fcb);		ExFreePool(Fcb->FileName.Buffer);#if _WIN32_WINNT >= 0x0501		FsRtlTeardownPerStreamContexts(&Fcb->AdvancedFCBHeader);#else		if (DokanFsRtlTeardownPerStreamContexts) {			DokanFsRtlTeardownPerStreamContexts(&Fcb->AdvancedFCBHeader);		}#endif		ExReleaseResourceLite(&Fcb->Resource);		ExDeleteResourceLite(&Fcb->Resource);		ExDeleteResourceLite(&Fcb->MainResource);		ExDeleteResourceLite(&Fcb->PagingIoResource);		InterlockedIncrement(&vcb->FcbFreed);		ExFreePool(Fcb);	} else {		ExReleaseResourceLite(&Fcb->Resource);	}	ExReleaseResourceLite(&vcb->Resource);	KeLeaveCriticalRegion();	return STATUS_SUCCESS;}

VOID FspFileNodeAcquireExclusiveF(FSP_FILE_NODE *FileNode, ULONG Flags){    PAGED_CODE();    FSP_FILE_NODE_GET_FLAGS();    FSP_FILE_NODE_ASSERT_FLAGS_CLR();    if (Flags & FspFileNodeAcquireMain)        ExAcquireResourceExclusiveLite(FileNode->Header.Resource, TRUE);    if (Flags & FspFileNodeAcquirePgio)        ExAcquireResourceExclusiveLite(FileNode->Header.PagingIoResource, TRUE);    FSP_FILE_NODE_SET_FLAGS();}

VOID FlushFcb(__in PDokanFCB fcb, __in_opt PFILE_OBJECT fileObject) {  if (fcb == NULL) {    return;  }  if (fcb->SectionObjectPointers.ImageSectionObject != NULL) {    DDbgPrint("  MmFlushImageSection FileName: %wZ FileCount: %lu./n",              &fcb->FileName, fcb->FileCount);    MmFlushImageSection(&fcb->SectionObjectPointers, MmFlushForWrite);    DDbgPrint("  MmFlushImageSection done FileName: %wZ FileCount: %lu./n",              &fcb->FileName, fcb->FileCount);  }  if (fcb->SectionObjectPointers.DataSectionObject != NULL) {    DDbgPrint("  CcFlushCache FileName: %wZ FileCount: %lu./n", &fcb->FileName,              fcb->FileCount);    ExAcquireResourceExclusiveLite(&fcb->PagingIoResource, TRUE);    CcFlushCache(&fcb->SectionObjectPointers, NULL, 0, NULL);    CcPurgeCacheSection(&fcb->SectionObjectPointers, NULL, 0, FALSE);    if (fileObject != NULL) {      CcUninitializeCacheMap(fileObject, NULL, NULL);    }    ExReleaseResourceLite(&fcb->PagingIoResource);    DDbgPrint("  CcFlushCache done FileName: %wZ FileCount: %lu./n",              &fcb->FileName, fcb->FileCount);  }}

NTSTATUSDokanFreeCCB(  __in PDokanCCB ccb  ){	PDokanFCB fcb;	ASSERT(ccb != NULL);		fcb = ccb->Fcb;	KeEnterCriticalRegion();	ExAcquireResourceExclusiveLite(&fcb->Resource, TRUE);	RemoveEntryList(&ccb->NextCCB);	ExReleaseResourceLite(&fcb->Resource);	KeLeaveCriticalRegion();	ExDeleteResourceLite(&ccb->Resource);	if (ccb->SearchPattern) {		ExFreePool(ccb->SearchPattern);	}	ExFreePool(ccb);	InterlockedIncrement(&fcb->Vcb->CcbFreed);	return STATUS_SUCCESS;}

VOID RemoveMountEntry(PDOKAN_GLOBAL dokanGlobal, PMOUNT_ENTRY MountEntry) {  ExAcquireResourceExclusiveLite(&dokanGlobal->Resource, TRUE);  RemoveEntryList(&MountEntry->ListEntry);  ExReleaseResourceLite(&dokanGlobal->Resource);  ExFreePool(MountEntry);}

NTSTATUSExt2FlushFiles(    IN PEXT2_IRP_CONTEXT    IrpContext,    IN PEXT2_VCB            Vcb,    IN BOOLEAN              bShutDown){    IO_STATUS_BLOCK    IoStatus;    PEXT2_FCB       Fcb;    PLIST_ENTRY     ListEntry;    if (IsFlagOn(Vcb->Flags, VCB_READ_ONLY) ||            IsFlagOn(Vcb->Flags, VCB_WRITE_PROTECTED)) {        return STATUS_SUCCESS;    }    IoStatus.Status = STATUS_SUCCESS;    DEBUG(DL_INF, ( "Flushing Files .../n"));    // Flush all Fcbs in Vcb list queue.    for (ListEntry = Vcb->FcbList.Flink;            ListEntry != &Vcb->FcbList;            ListEntry = ListEntry->Flink ) {        Fcb = CONTAINING_RECORD(ListEntry, EXT2_FCB, Next);        ExAcquireResourceExclusiveLite(            &Fcb->MainResource, TRUE);        IoStatus.Status = Ext2FlushFile(IrpContext, Fcb, NULL);        ExReleaseResourceLite(&Fcb->MainResource);    }    return IoStatus.Status;}

staticVOIDTestResourceSharedAccess(    IN PERESOURCE Res){    LONG Count = 0;    KeEnterCriticalRegion();    ok_bool_true(ExAcquireResourceSharedLite(Res, FALSE), "ExAcquireResourceSharedLite returned"); ++Count;    CheckResourceStatus(Res, FALSE, Count, 0LU, 0LU);    ok_bool_true(ExAcquireResourceSharedLite(Res, FALSE), "ExAcquireResourceSharedLite returned"); ++Count;    ok_bool_true(ExAcquireResourceSharedLite(Res, TRUE), "ExAcquireResourceSharedLite returned"); ++Count;    ok_bool_true(ExAcquireSharedStarveExclusive(Res, FALSE), "ExAcquireSharedStarveExclusive returned"); ++Count;    ok_bool_true(ExAcquireSharedStarveExclusive(Res, TRUE), "ExAcquireSharedStarveExclusive returned"); ++Count;    ok_bool_true(ExAcquireSharedWaitForExclusive(Res, FALSE), "ExAcquireSharedWaitForExclusive returned"); ++Count;    ok_bool_true(ExAcquireSharedWaitForExclusive(Res, TRUE), "ExAcquireSharedWaitForExclusive returned"); ++Count;    CheckResourceStatus(Res, FALSE, Count, 0LU, 0LU);    /* this one fails, TRUE would deadlock */    ok_bool_false(ExAcquireResourceExclusiveLite(Res, FALSE), "ExAcquireResourceExclusiveLite returned");    CheckResourceStatus(Res, FALSE, Count, 0LU, 0LU);    /* this asserts */    if (!KmtIsCheckedBuild)        ExConvertExclusiveToSharedLite(Res);    CheckResourceStatus(Res, FALSE, Count, 0LU, 0LU);    while (Count--)        ExReleaseResourceLite(Res);    KeLeaveCriticalRegion();}

void dc_add_password(dc_pass *pass){	dsk_pass *d_pass;	if (pass->size != 0)	{		KeEnterCriticalRegion();		ExAcquireResourceExclusiveLite(&p_resource, TRUE);		for (d_pass = f_pass; d_pass; d_pass = d_pass->next)		{			if (IS_EQUAL_PASS(pass, &d_pass->pass)) {				break;			}		}		if ( (d_pass == NULL) && (d_pass = mm_secure_alloc(sizeof(dsk_pass))) )		{			memcpy(&d_pass->pass, pass, sizeof(dc_pass));			d_pass->next = f_pass;			f_pass       = d_pass;		}		ExReleaseResourceLite(&p_resource);		KeLeaveCriticalRegion();	}}

VOIDThreadNotifyCallback (    HANDLE  ProcessId,    HANDLE  ThreadId,    BOOLEAN  Create ){    DbgPrint ( "%s ProcessId=%x ThreadId=%x %s/n", __FUNCTION__,        ProcessId,        ThreadId,        Create ? "CREATED" : "DESTROYED" );    if ( Create ) {        // Step #2 : Acquire the lock that protects the g_Tidxxx globals         // (KeEnterCriticalRegion() and ExAcquireResourceExclusiveLite())        KeEnterCriticalRegion();        ExAcquireResourceExclusiveLite(&g_TidLock, TRUE);        g_TidArray[g_TidIndex] = ThreadId;        g_TidIndex++;        if ( g_TidIndex >= TID_ARRAY_SIZE ) {            g_TidIndex = 0;        }        // Step #3 : Release the lock that protects the g_Tidxxx globals         // (KeLeaveCriticalRegion() and ExReleaseResourceLite())        ExReleaseResourceLite(&g_TidLock);        KeLeaveCriticalRegion();    }}

NTSTATUSDokanFilterCallbackAcquireForCreateSection(__in PFS_FILTER_CALLBACK_DATA                                               CallbackData,                                           __out PVOID *CompletionContext) {  PFSRTL_ADVANCED_FCB_HEADER header;  PDokanFCB fcb = NULL;  PDokanCCB ccb;  UNREFERENCED_PARAMETER(CompletionContext);  DDbgPrint("DokanFilterCallbackAcquireForCreateSection/n");  header = CallbackData->FileObject->FsContext;  ccb = CallbackData->FileObject->FsContext2;  if (ccb)    fcb = ccb->Fcb;  if (header && header->Resource) {    KeEnterCriticalRegion();    ExAcquireResourceExclusiveLite(header->Resource, TRUE);    KeLeaveCriticalRegion();  }  if (CallbackData->Parameters.AcquireForSectionSynchronization.SyncType !=      SyncTypeCreateSection) {    return STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY;  } else if (fcb && fcb->ShareAccess.Writers == 0) {    return STATUS_FILE_LOCKED_WITH_ONLY_READERS;  } else {    return STATUS_FILE_LOCKED_WITH_WRITERS;  }}

VOID FASTCALL UserEnterExclusive(VOID){    ASSERT_NOGDILOCKS();    KeEnterCriticalRegion();    ExAcquireResourceExclusiveLite(&UserLock, TRUE);    gptiCurrent = PsGetCurrentThreadWin32Thread();}

static NTSTATUS pnp_remove_device(PDEVICE_OBJECT DeviceObject) {    device_extension* Vcb = DeviceObject->DeviceExtension;    NTSTATUS Status;    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);    Status = send_disks_pnp_message(Vcb, IRP_MN_REMOVE_DEVICE);    if (!NT_SUCCESS(Status))        WARN("send_disks_pnp_message returned %08x/n", Status);    ExReleaseResourceLite(&Vcb->tree_lock);    if (DeviceObject->Vpb->Flags & VPB_MOUNTED) {        Status = FsRtlNotifyVolumeEvent(Vcb->root_file, FSRTL_VOLUME_DISMOUNT);        if (!NT_SUCCESS(Status)) {            WARN("FsRtlNotifyVolumeEvent returned %08x/n", Status);        }        if (Vcb->vde)            Vcb->vde->mounted_device = NULL;        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);        Vcb->removing = TRUE;        ExReleaseResourceLite(&Vcb->tree_lock);        if (Vcb->open_files == 0)            uninit(Vcb);    }    return STATUS_SUCCESS;}

VOIDFFSFreeCcb(	IN PFFS_CCB Ccb){	ASSERT(Ccb != NULL);	ASSERT((Ccb->Identifier.Type == FFSCCB) &&			(Ccb->Identifier.Size == sizeof(FFS_CCB)));	if (Ccb->DirectorySearchPattern.Buffer != NULL)	{		ExFreePool(Ccb->DirectorySearchPattern.Buffer);	}	if (FlagOn(Ccb->Flags, CCB_FROM_POOL))	{		ExFreePool(Ccb);	}	else	{		ExAcquireResourceExclusiveLite(				&FFSGlobal->LAResource,				TRUE);		ExFreeToNPagedLookasideList(&(FFSGlobal->FFSCcbLookasideList), Ccb);		ExReleaseResourceForThreadLite(				&FFSGlobal->LAResource,				ExGetCurrentResourceThread());	}}

staticNTSTATUSVfatFlushFile(    PDEVICE_EXTENSION DeviceExt,    PVFATFCB Fcb){    IO_STATUS_BLOCK IoStatus;    NTSTATUS Status;    DPRINT("VfatFlushFile(DeviceExt %p, Fcb %p) for '%wZ'/n", DeviceExt, Fcb, &Fcb->PathNameU);    CcFlushCache(&Fcb->SectionObjectPointers, NULL, 0, &IoStatus);    if (IoStatus.Status == STATUS_INVALID_PARAMETER)    {        /* FIXME: Caching was possible not initialized */        IoStatus.Status = STATUS_SUCCESS;    }    ExAcquireResourceExclusiveLite(&DeviceExt->DirResource, TRUE);    if (BooleanFlagOn(Fcb->Flags, FCB_IS_DIRTY))    {        Status = VfatUpdateEntry(DeviceExt, Fcb);        if (!NT_SUCCESS(Status))        {            IoStatus.Status = Status;        }    }    ExReleaseResourceLite(&DeviceExt->DirResource);    return IoStatus.Status;}

/* * @implemented */VOIDNTAPIIoUnregisterFileSystem(IN PDEVICE_OBJECT DeviceObject){    PAGED_CODE();    /* Acquire the FS lock */    KeEnterCriticalRegion();    ExAcquireResourceExclusiveLite(&IopDatabaseResource, TRUE);    /* Simply remove the entry - if queued */    if (DeviceObject->Queue.ListEntry.Flink)    {        RemoveEntryList(&DeviceObject->Queue.ListEntry);    }    /* And notify all registered file systems */    IopNotifyFileSystemChange(DeviceObject, FALSE);    /* Update operations counter */    IopFsRegistrationOps++;    /* Then release the lock */    ExReleaseResourceLite(&IopDatabaseResource);    KeLeaveCriticalRegion();    /* Decrease reference count to allow unload */    IopInterlockedDecrementUlong(LockQueueIoDatabaseLock, (PULONG)&DeviceObject->ReferenceCount);}

NTSTATUSDokanFreeCCB(  __in PDokanCCB ccb  ){	PDokanFCB fcb;	ASSERT(ccb != NULL);		fcb = ccb->Fcb;	ExAcquireResourceExclusiveLite(&fcb->Resource, TRUE);	RemoveEntryList(&ccb->NextCCB);	ExReleaseResourceLite(&fcb->Resource);	ExDeleteResourceLite(&ccb->Resource);	if (ccb->SearchPattern) {		ExFreePool(ccb->SearchPattern);	}	ExFreePool(ccb);	return STATUS_SUCCESS;}

PDokanCCBDokanAllocateCCB(	__in PDokanDCB	Dcb,	__in PDokanFCB	Fcb	){	PDokanCCB ccb = ExAllocatePool(sizeof(DokanCCB));	if (ccb == NULL)		return NULL;	ASSERT(ccb != NULL);	ASSERT(Fcb != NULL);	RtlZeroMemory(ccb, sizeof(DokanCCB));	ccb->Identifier.Type = CCB;	ccb->Identifier.Size = sizeof(DokanCCB);	ccb->Fcb = Fcb;	ExInitializeResourceLite(&ccb->Resource);	InitializeListHead(&ccb->NextCCB);	ExAcquireResourceExclusiveLite(&Fcb->Resource, TRUE);	InsertTailList(&Fcb->NextCCB, &ccb->NextCCB);	ExReleaseResourceLite(&Fcb->Resource);	ccb->MountId = Dcb->MountId;	return ccb;}

__drv_mustHoldCriticalRegionNTSTATUSRfsdPnpCancelRemove (    PRFSD_IRP_CONTEXT IrpContext,    PRFSD_VCB         Vcb    ){    NTSTATUS Status;    PAGED_CODE();    RfsdPrint((DBG_PNP, "RfsdPnpCancelRemove by RfsdPnp .../n"));    ExAcquireResourceExclusiveLite(        &Vcb->MainResource,  TRUE );    Status = RfsdUnlockVcb(Vcb, IrpContext->FileObject);    ExReleaseResourceForThreadLite(        &Vcb->MainResource,        ExGetCurrentResourceThread());    IoSkipCurrentIrpStackLocation(IrpContext->Irp);    Status = IoCallDriver(Vcb->TargetDeviceObject, IrpContext->Irp);    IrpContext->Irp = NULL;    return Status;}

////	IOCTL_PREPARE_TO_UNLOAD//NTSTATUS LklPrepareToUnload(PDEVICE_OBJECT device,PIRP irp){	NTSTATUS status = STATUS_SUCCESS;	BOOLEAN acq_resource = FALSE;	CHECK_OUT(device != lklfsd.device, STATUS_INVALID_DEVICE_REQUEST);	ExAcquireResourceExclusiveLite(&lklfsd.global_resource, TRUE);	acq_resource = TRUE;	CHECK_OUT_MSG(FLAG_ON(lklfsd.flags, VFS_UNLOAD_PENDING), STATUS_ACCESS_DENIED,		"Aldready ready to unload");	CHECK_OUT_MSG(!IsListEmpty(&lklfsd.vcb_list), STATUS_ACCESS_DENIED,		"Mounted volumes exists");    	DbgPrint("Unloading LklVfs");	IoUnregisterFileSystem(lklfsd.device);	//unload_linux_kernel();    	IoDeleteDevice(lklfsd.device);             lklfsd.driver->DriverUnload = DriverUnload;	SET_FLAG(lklfsd.flags, VFS_UNLOAD_PENDING);try_exit:	if (acq_resource)		RELEASE(&lklfsd.global_resource);	return status;}

void dc_clean_pass_cache(){	dsk_pass *d_pass;	dsk_pass *c_pass;	int       loirql;	if (loirql = (KeGetCurrentIrql() == PASSIVE_LEVEL)) {		KeEnterCriticalRegion();		ExAcquireResourceExclusiveLite(&p_resource, TRUE);	}	for (d_pass = f_pass; d_pass;)	{		c_pass = d_pass;		d_pass = d_pass->next;		/* zero password data */		burn(c_pass, sizeof(dsk_pass));		/* free memory if possible */		if (loirql != 0) mm_secure_free(c_pass);	}	f_pass = NULL;	if (loirql != 0) {		ExReleaseResourceLite(&p_resource);		KeLeaveCriticalRegion();	}}

__drv_mustHoldCriticalRegionVOIDFFSFreeMcb(	IN PFFS_MCB Mcb){#ifndef __REACTOS__    PFFS_MCB   Parent = Mcb->Parent;#endif    PAGED_CODE();	ASSERT(Mcb != NULL);	ASSERT((Mcb->Identifier.Type == FFSMCB) &&			(Mcb->Identifier.Size == sizeof(FFS_MCB)));	FFSPrint((DBG_INFO, "FFSFreeMcb: Mcb %S will be freed./n", Mcb->ShortName.Buffer));	if (Mcb->ShortName.Buffer)		ExFreePool(Mcb->ShortName.Buffer);	if (FlagOn(Mcb->Flags, MCB_FROM_POOL))	{		ExFreePool(Mcb);	}	else	{		ExAcquireResourceExclusiveLite(				&FFSGlobal->LAResource,				TRUE);		ExFreeToPagedLookasideList(&(FFSGlobal->FFSMcbLookasideList), Mcb);		ExReleaseResourceForThreadLite(				&FFSGlobal->LAResource,				ExGetCurrentResourceThread());	}	ExAcquireResourceExclusiveLite(			&FFSGlobal->CountResource,			TRUE);	FFSGlobal->McbAllocated--;	ExReleaseResourceForThreadLite(			&FFSGlobal->CountResource,			ExGetCurrentResourceThread());}

staticNTSTATUSVfatDismountVolume(    PVFAT_IRP_CONTEXT IrpContext){    PDEVICE_EXTENSION DeviceExt;    PLIST_ENTRY NextEntry;    PVFATFCB Fcb;    PFILE_OBJECT FileObject;    DPRINT("VfatDismountVolume(%p)/n", IrpContext);    DeviceExt = IrpContext->DeviceExt;    FileObject = IrpContext->FileObject;    /* We HAVE to be locked. Windows also allows dismount with no lock     * but we're here mainly for 1st stage, so KISS     */    if (!(DeviceExt->Flags & VCB_VOLUME_LOCKED))    {        return STATUS_ACCESS_DENIED;    }    /* Race condition? */    if (DeviceExt->Flags & VCB_DISMOUNT_PENDING)    {        return STATUS_VOLUME_DISMOUNTED;    }    /* Notify we'll dismount. Pass that point there's no reason we fail */    FsRtlNotifyVolumeEvent(IrpContext->Stack->FileObject, FSRTL_VOLUME_DISMOUNT);    ExAcquireResourceExclusiveLite(&DeviceExt->FatResource, TRUE);    /* Flush volume & files */    VfatFlushVolume(DeviceExt, (PVFATFCB)FileObject->FsContext);    /* Rebrowse the FCB in order to free them now */    while (!IsListEmpty(&DeviceExt->FcbListHead))    {        NextEntry = RemoveHeadList(&DeviceExt->FcbListHead);        Fcb = CONTAINING_RECORD(NextEntry, VFATFCB, FcbListEntry);        vfatDestroyFCB(Fcb);    }    /* Mark we're being dismounted */    DeviceExt->Flags |= VCB_DISMOUNT_PENDING;    ExReleaseResourceLite(&DeviceExt->FatResource);    /* Release a few resources and quit, we're done */    ExDeleteResourceLite(&DeviceExt->DirResource);    ExDeleteResourceLite(&DeviceExt->FatResource);    ObDereferenceObject(DeviceExt->FATFileObject);    return STATUS_SUCCESS;}

BOOLEAN MrLockGlobal(BOOLEAN ex){    KeEnterCriticalRegion();    if (!ex)        return ExAcquireResourceSharedLite(&g_core.mc_lock, TRUE);    return ExAcquireResourceExclusiveLite(&g_core.mc_lock, TRUE);}

/* * @implemented */VOIDNTAPISeLockSubjectContext(IN PSECURITY_SUBJECT_CONTEXT SubjectContext){    PAGED_CODE();    KeEnterCriticalRegion();    ExAcquireResourceExclusiveLite(&SepSubjectContextLock, TRUE);}

////	acquire for lazy write//BOOLEAN DDKAPI VfsAcqLazyWrite(PVOID context, BOOLEAN wait){	PLKLFCB	fcb = (PLKLFCB) context;	ASSERT(fcb);	ASSERT((fcb->id.type == FCB) && (fcb->id.size == sizeof(LKLFCB)));	return ExAcquireResourceExclusiveLite(&fcb->fcb_resource, wait);}

NTSTATUS vol_close(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {    volume_device_extension* vde = DeviceObject->DeviceExtension;    pdo_device_extension* pdode = vde->pdode;    TRACE("(%p, %p)/n", DeviceObject, Irp);    Irp->IoStatus.Information = 0;    ExAcquireResourceExclusiveLite(&pdo_list_lock, TRUE);    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);    if (InterlockedDecrement(&vde->open_count) == 0 && vde->removing) {        NTSTATUS Status;        UNICODE_STRING mmdevpath;        PDEVICE_OBJECT mountmgr;        PFILE_OBJECT mountmgrfo;        PDEVICE_OBJECT pdo;        RtlInitUnicodeString(&mmdevpath, MOUNTMGR_DEVICE_NAME);        Status = IoGetDeviceObjectPointer(&mmdevpath, FILE_READ_ATTRIBUTES, &mountmgrfo, &mountmgr);        if (!NT_SUCCESS(Status))            ERR("IoGetDeviceObjectPointer returned %08x/n", Status);        else {            remove_drive_letter(mountmgr, &vde->name);            ObDereferenceObject(mountmgrfo);        }        if (vde->mounted_device) {            device_extension* Vcb = vde->mounted_device->DeviceExtension;            Vcb->vde = NULL;        }        if (vde->name.Buffer)            ExFreePool(vde->name.Buffer);        ExReleaseResourceLite(&pdode->child_lock);        ExDeleteResourceLite(&pdode->child_lock);        if (vde->pdo->AttachedDevice)            IoDetachDevice(vde->pdo);        pdo = vde->pdo;        IoDeleteDevice(vde->device);        if (!no_pnp)            IoDeleteDevice(pdo);    } else        ExReleaseResourceLite(&pdode->child_lock);    ExReleaseResourceLite(&pdo_list_lock);    return STATUS_SUCCESS;}