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

static NTSTATUS pnp_cancel_remove_device(PDEVICE_OBJECT DeviceObject) {    device_extension* Vcb = DeviceObject->DeviceExtension;    NTSTATUS Status;    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);    ExAcquireResourceSharedLite(&Vcb->fileref_lock, TRUE);    if (Vcb->root_fileref && Vcb->root_fileref->fcb && (Vcb->root_fileref->open_count > 0 || has_open_children(Vcb->root_fileref))) {        Status = STATUS_ACCESS_DENIED;        goto end;    }    Status = send_disks_pnp_message(Vcb, IRP_MN_CANCEL_REMOVE_DEVICE);    if (!NT_SUCCESS(Status)) {        WARN("send_disks_pnp_message returned %08x/n", Status);        goto end;    }end:    ExReleaseResourceLite(&Vcb->fileref_lock);    ExReleaseResourceLite(&Vcb->tree_lock);    return STATUS_SUCCESS;}

BOOLEAN FspFileNodeTryAcquireSharedF(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 = ExAcquireResourceSharedLite(FileNode->Header.Resource, Wait);        if (!Result)            return FALSE;    }    if (Flags & FspFileNodeAcquirePgio)    {        Result = ExAcquireResourceSharedLite(FileNode->Header.PagingIoResource, Wait);        if (!Result)        {            if (Flags & FspFileNodeAcquireMain)                ExReleaseResourceLite(FileNode->Header.Resource);            return FALSE;        }    }    if (Result)        FSP_FILE_NODE_SET_FLAGS();    return Result;}

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();}

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 FspFileNodeAcquireSharedF(FSP_FILE_NODE *FileNode, ULONG Flags){    PAGED_CODE();    FSP_FILE_NODE_GET_FLAGS();    FSP_FILE_NODE_ASSERT_FLAGS_CLR();    if (Flags & FspFileNodeAcquireMain)        ExAcquireResourceSharedLite(FileNode->Header.Resource, TRUE);    if (Flags & FspFileNodeAcquirePgio)        ExAcquireResourceSharedLite(FileNode->Header.PagingIoResource, TRUE);    FSP_FILE_NODE_SET_FLAGS();}

VOID DokanCheckKeepAlive(__in PDokanDCB Dcb) {  LARGE_INTEGER tickCount;  ULONG mounted;  // DDbgPrint("==> DokanCheckKeepAlive/n");  KeEnterCriticalRegion();  KeQueryTickCount(&tickCount);  ExAcquireResourceSharedLite(&Dcb->Resource, TRUE);  if (Dcb->TickCount.QuadPart < tickCount.QuadPart) {    mounted = Dcb->Mounted;    ExReleaseResourceLite(&Dcb->Resource);    DDbgPrint("  Timeout, umount/n");    if (!mounted) {      // not mounted      KeLeaveCriticalRegion();      return;    }    DokanUnmount(Dcb);  } else {    ExReleaseResourceLite(&Dcb->Resource);  }  KeLeaveCriticalRegion();  // DDbgPrint("<== DokanCheckKeepAlive/n");}

static NTSTATUS vol_get_length(volume_device_extension* vde, PIRP Irp) {    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);    pdo_device_extension* pdode = vde->pdode;    GET_LENGTH_INFORMATION* gli;    LIST_ENTRY* le;    if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(GET_LENGTH_INFORMATION))        return STATUS_BUFFER_TOO_SMALL;    gli = (GET_LENGTH_INFORMATION*)Irp->AssociatedIrp.SystemBuffer;    gli->Length.QuadPart = 0;    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);    le = pdode->children.Flink;    while (le != &pdode->children) {        volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);        gli->Length.QuadPart += vc->size;        le = le->Flink;    }    ExReleaseResourceLite(&pdode->child_lock);    Irp->IoStatus.Information = sizeof(GET_LENGTH_INFORMATION);    return STATUS_SUCCESS;}

static NTSTATUS vol_is_writable(volume_device_extension* vde) {    pdo_device_extension* pdode = vde->pdode;    NTSTATUS Status;    LIST_ENTRY* le;    BOOL writable = FALSE;    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);    le = pdode->children.Flink;    while (le != &pdode->children) {        volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);        Status = dev_ioctl(vc->devobj, IOCTL_DISK_IS_WRITABLE, NULL, 0, NULL, 0, TRUE, NULL);        if (NT_SUCCESS(Status)) {            writable = TRUE;            break;        } else if (Status != STATUS_MEDIA_WRITE_PROTECTED)            goto end;        le = le->Flink;    }    Status = writable ? STATUS_SUCCESS : STATUS_MEDIA_WRITE_PROTECTED;end:ExReleaseResourceLite(&pdode->child_lock);    return STATUS_SUCCESS;}

BOOLEANCdAcquireForCache (    _Inout_ PFCB Fcb,    _In_ BOOLEAN Wait    )/*++Routine Description:    The address of this routine is specified when creating a CacheMap for    a file.  It is subsequently called by the Lazy Writer for synchronization.Arguments:    Fcb -  The pointer supplied as context to the cache initialization           routine.    Wait - TRUE if the caller is willing to block.Return Value:    None--*/{    PAGED_CODE();    NT_ASSERT(IoGetTopLevelIrp() == NULL);    IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);    return ExAcquireResourceSharedLite( Fcb->Resource, Wait );}

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;}

dev_hook *dc_find_hook(wchar_t *dev_name){	PLIST_ENTRY entry;	dev_hook   *hook;	dev_hook   *found = NULL;	KeEnterCriticalRegion();	ExAcquireResourceSharedLite(&hooks_sync_resource, TRUE);	entry = hooks_list_head.Flink;	while (entry != &hooks_list_head)	{		hook  = CONTAINING_RECORD(entry, dev_hook, hooks_list);		entry = entry->Flink;		if (_wcsicmp(hook->dev_name, dev_name) == 0) {			dc_reference_hook(hook);			found = hook; break;		}	}		ExReleaseResourceLite(&hooks_sync_resource);	KeLeaveCriticalRegion();	return found;}

static NTSTATUS vol_check_verify(volume_device_extension* vde) {    pdo_device_extension* pdode = vde->pdode;    NTSTATUS Status;    LIST_ENTRY* le;    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);    le = pdode->children.Flink;    while (le != &pdode->children) {        volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);        Status = dev_ioctl(vc->devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, NULL, 0, FALSE, NULL);        if (!NT_SUCCESS(Status))            goto end;        le = le->Flink;    }    Status = STATUS_SUCCESS;end:    ExReleaseResourceLite(&pdode->child_lock);    return Status;}

static int dc_probe_decrypt(dev_hook *hook, dc_header **header, xts_key **res_key, dc_pass *password){	xts_key  *hdr_key;	dsk_pass *d_pass;		int       resl, succs;	hdr_key = NULL; succs = 0; *header = NULL;	do	{		/* read raw volume header */		if ( (resl = io_read_header(hook, header, NULL, NULL)) != ST_OK ) {			break;		}		if ( (hdr_key = mm_secure_alloc(sizeof(xts_key))) == NULL ) {			resl = ST_NOMEM; break;		}		/* derive header key and decrypt header */		do		{			if (password != NULL)			{				/* probe mount with entered password */				if (succs = cp_decrypt_header(hdr_key, *header, password)) {					break;				}			}			KeEnterCriticalRegion();			ExAcquireResourceSharedLite(&p_resource, TRUE);			/* probe mount with cached passwords */			for (d_pass = f_pass; d_pass; d_pass = d_pass->next)			{				if (succs = cp_decrypt_header(hdr_key, *header, &d_pass->pass)) {					break;				}			}			ExReleaseResourceLite(&p_resource);			KeLeaveCriticalRegion();		} while (0);		if (succs != 0) {			*res_key = hdr_key; hdr_key = NULL; resl = ST_OK; 		} else {			resl = ST_PASS_ERR;		}	} while (0);	if (resl != ST_OK && *header != NULL) {		mm_secure_free(*header); *header = NULL;	}	if (hdr_key != NULL) {		mm_secure_free(hdr_key);	}	return resl;}

////	acquire for read ahead//BOOLEAN DDKAPI VfsAcqReadAhead(PVOID context, BOOLEAN wait){	PLKLFCB fcb = (PLKLFCB) context;	ASSERT(fcb);	ASSERT((fcb->id.type == FCB) && (fcb->id.size == sizeof(PLKLFCB)));		return ExAcquireResourceSharedLite(&(fcb->fcb_resource), wait);}

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

VOIDFLTAPIFltUnregisterFilter(_In_ PFLT_FILTER Filter){    PFLT_INSTANCE Instance;    PLIST_ENTRY CurrentEntry;    NTSTATUS Status;    /* Set the draining flag */    Status = FltpStartingToDrainObject(&Filter->Base);    if (!NT_SUCCESS(Status))    {        /* Someone already unregistered us, just remove our ref and bail */        FltObjectDereference(&Filter->Base);        return;    }    /* Lock the instance list */    KeEnterCriticalRegion();    ExAcquireResourceSharedLite(&Filter->InstanceList.rLock, TRUE);    /* Set the first entry in the list */    CurrentEntry = Filter->InstanceList.rList.Flink;    /* Free all instances referenced by the filter */    while (CurrentEntry != &Filter->InstanceList.rList)    {        /* Get the record pointer */        Instance = CONTAINING_RECORD(CurrentEntry, FLT_INSTANCE, FilterLink);        // FIXME: implement        (void)Instance;        /* Reset the pointer and move to next entry */        Instance = NULL;        CurrentEntry = CurrentEntry->Flink;    }    /* We're done with instances now */    ExReleaseResourceLite(&Filter->InstanceList.rLock);    KeLeaveCriticalRegion();    /* Remove the reference from the base object */    FltObjectDereference(&Filter->Base);    /* Wait until we're sure nothing is using the filter */    FltpObjectRundownWait(&Filter->Base.RundownRef);    /* Delete the instance list lock */    ExDeleteResourceLite(&Filter->InstanceList.rLock);    /* We're finished cleaning up now */    FltpExRundownCompleted(&Filter->Base.RundownRef);    /* Hand the memory back */    ExFreePoolWithTag(Filter, FM_TAG_FILTER);}

BOOLEANExt2FastIoWrite (    IN PFILE_OBJECT         FileObject,    IN PLARGE_INTEGER       FileOffset,    IN ULONG                Length,    IN BOOLEAN              Wait,    IN ULONG                LockKey,    OUT PVOID               Buffer,    OUT PIO_STATUS_BLOCK    IoStatus,    IN PDEVICE_OBJECT       DeviceObject){    PEXT2_FCB   Fcb = NULL;    BOOLEAN     Status = FALSE;    BOOLEAN     Locked = FALSE;    Fcb = (PEXT2_FCB) FileObject->FsContext;    if (Fcb == NULL)        return FALSE;    __try {        FsRtlEnterFileSystem();        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));        if (IsFlagOn(Fcb->Vcb->Flags, VCB_READ_ONLY)) {            __leave;        }        ExAcquireResourceSharedLite(&Fcb->MainResource, TRUE);        Locked = TRUE;        if (IsEndOfFile(*FileOffset) || ((LONGLONG)(Fcb->Inode->i_size) <                                         (FileOffset->QuadPart + Length)) ) {        } else {            ExReleaseResourceLite(&Fcb->MainResource);            Locked = FALSE;            Status = FsRtlCopyWrite(FileObject, FileOffset, Length, Wait,                                    LockKey, Buffer, IoStatus, DeviceObject);        }    } __finally {        if (Locked) {            ExReleaseResourceLite(&Fcb->MainResource);        }        FsRtlExitFileSystem();    }    DEBUG(DL_IO, ("Ext2FastIoWrite: %wZ Offset: %I64xh Length: %xh Key: %xh Status=%d/n",                   &Fcb->Mcb->ShortName,  FileOffset->QuadPart, Length, LockKey, Status));    return Status;}

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;}

VOIDDokanCheckKeepAlive(	PDEVICE_EXTENSION	DeviceExtension){	LARGE_INTEGER		tickCount;	ULONG				eventLength;	PEVENT_CONTEXT		eventContext;	ULONG				mounted;	//DDbgPrint("==> DokanCheckKeepAlive/n");	KeQueryTickCount(&tickCount);	ExAcquireResourceSharedLite(&DeviceExtension->Resource, TRUE);	if ( (tickCount.QuadPart - DeviceExtension->TickCount.QuadPart) * KeQueryTimeIncrement()		> DOKAN_KEEPALIVE_TIMEOUT * 10000 * 1000) {			mounted = DeviceExtension->Mounted;		ExReleaseResourceLite(&DeviceExtension->Resource);		DDbgPrint("  Force to umount/n");		if (!mounted) {			// not mounted			return;		}		eventLength = sizeof(EVENT_CONTEXT);		eventContext = ExAllocatePool(eventLength);						if (eventContext == NULL) {			;//STATUS_INSUFFICIENT_RESOURCES;			DokanEventRelease(DeviceExtension->DeviceObject);			return;		}		RtlZeroMemory(eventContext, eventLength);		eventContext->Length = eventLength;		// set drive letter		eventContext->Flags = mounted;		DokanEventNotification(&DeviceExtension->Global->NotifyService, eventContext);		DokanEventRelease(DeviceExtension->DeviceObject);	} else {		ExReleaseResourceLite(&DeviceExtension->Resource);	}	//DDbgPrint("<== DokanCheckKeepAlive/n");}

VOID SortedListReadLock(IN PSORTED_LIST pSortedList){    ASSERTMSG("Pointer to sorted list must not be NULL", pSortedList != NULL);    ASSERTMSG("Calling lock routine for single threaded list!", pSortedList->bIsMultiThread == TRUE);    ASSERTMSG("Sorted list lock acquire must occur at or below APC_LEVEL", KeGetCurrentIrql() <= APC_LEVEL);    // acquire shared lock -- multiple readers can access the list at the same time    KeEnterCriticalRegion();    ExAcquireResourceSharedLite(pSortedList->pLock, TRUE);    InterlockedIncrement(&pSortedList->lReaderCount);}

static NTSTATUS bus_query_device_relations(PIRP Irp) {    NTSTATUS Status;    ULONG num_children;    LIST_ENTRY* le;    ULONG drsize, i;    DEVICE_RELATIONS* dr;    ExAcquireResourceSharedLite(&pdo_list_lock, TRUE);    num_children = 0;    le = pdo_list.Flink;    while (le != &pdo_list) {        num_children++;        le = le->Flink;    }    drsize = offsetof(DEVICE_RELATIONS, Objects[0]) + (num_children * sizeof(PDEVICE_OBJECT));    dr = ExAllocatePoolWithTag(PagedPool, drsize, ALLOC_TAG);    if (!dr) {        ERR("out of memory/n");        Status = STATUS_INSUFFICIENT_RESOURCES;        goto end;    }    dr->Count = num_children;    i = 0;    le = pdo_list.Flink;    while (le != &pdo_list) {        pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);        ObReferenceObject(pdode->pdo);        dr->Objects[i] = pdode->pdo;        i++;        le = le->Flink;    }    Irp->IoStatus.Information = (ULONG_PTR)dr;    Status = STATUS_SUCCESS;end:    ExReleaseResourceLite(&pdo_list_lock);    Irp->IoStatus.Status = Status;    IoCompleteRequest(Irp, IO_NO_INCREMENT);    return Status;}

static BOOLEAN acquire_for_read_ahead(PVOID Context, BOOLEAN Wait) {    PFILE_OBJECT FileObject = Context;    fcb* fcb = FileObject->FsContext;    TRACE("(%p, %u)/n", Context, Wait);    if (!ExAcquireResourceSharedLite(fcb->Header.Resource, Wait))        return FALSE;    IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);    return TRUE;}

STATICPAGEABLENTSTATUSmessagetable_AcquireLock(	_In_	PMESSAGE_TABLE	ptMessageTable,	_In_	BOOLEAN			bExclusive){	NTSTATUS	eStatus					= STATUS_UNSUCCESSFUL;	BOOLEAN		bResult					= FALSE;	BOOLEAN		bLeaveCriticalRegion	= FALSE;	BOOLEAN		bReleaseLock			= FALSE;	PAGED_CODE();	ASSERT(NULL != ptMessageTable);	KeEnterCriticalRegion();	bLeaveCriticalRegion = TRUE;	bResult =		(bExclusive)		? (ExAcquireResourceExclusiveLite(&(ptMessageTable->tLock), TRUE))		: (ExAcquireResourceSharedLite(&(ptMessageTable->tLock), TRUE));	if (!bResult)	{		eStatus = STATUS_LOCK_NOT_GRANTED;		goto lblCleanup;	}	bReleaseLock = TRUE;	// All done!	bReleaseLock = FALSE;	bLeaveCriticalRegion = FALSE;	eStatus = STATUS_SUCCESS;lblCleanup:	if (bReleaseLock)	{		ExReleaseResourceLite(&(ptMessageTable->tLock));		bReleaseLock = FALSE;	}	if (bLeaveCriticalRegion)	{		KeLeaveCriticalRegion();		bLeaveCriticalRegion = FALSE;	}	return eStatus;}

FINISHEDFatAcquireSharedVcb (    IN PIRP_CONTEXT IrpContext,    IN PVCB Vcb    )/*++Routine Description:    This routine acquires shared access to the Vcb.    After we acquire the resource check to see if this operation is legal.    If it isn't (ie. we get an exception), release the resource.Arguments:    Vcb - Supplies the Vcb to acquireReturn Value:    FINISHED - TRUE if we have the resource and FALSE if we needed to block        for the resource but Wait is FALSE.--*/{    PAGED_CODE();    if (ExAcquireResourceSharedLite( &Vcb->Resource,                                      BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT))) {        try {            FatVerifyOperationIsLegal( IrpContext );        } finally {            if ( AbnormalTermination() ) {                FatReleaseVcb( IrpContext, Vcb );            }        }        return TRUE;    }    return FALSE;}

static BOOLEAN STDCALL acquire_for_lazy_write(PVOID Context, BOOLEAN Wait) {    PFILE_OBJECT FileObject = Context;    fcb* fcb = FileObject->FsContext;        TRACE("(%p, %u)/n", Context, Wait);    //     if (!fcb || FileObject->Flags & FO_CLEANUP_COMPLETE)//         return FALSE;    if (!ExAcquireResourceSharedLite(fcb->Header.PagingIoResource, Wait))        return FALSE;        fcb->lazy_writer_thread = KeGetCurrentThread();        return TRUE;}

BOOLEANNTAPIFatAcquireSharedVcb(IN PFAT_IRP_CONTEXT IrpContext,                    IN PVCB Vcb){    /* Acquire VCB's resource if possible */    if (ExAcquireResourceSharedLite(&Vcb->Resource,                                    BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT)))    {        return TRUE;    }    else    {        return FALSE;    }}

static VOID _HandleTableLockShared(PCHANDLE_TABLE HandleTable, PKIRQL Irql){	switch (HandleTable->HandleTableType) {		case httPassiveLevel:			KeEnterCriticalRegion();			ExAcquireResourceSharedLite(&HandleTable->LockP, TRUE);			break;		case httDispatchLevel:			KeAcquireSpinLock(&HandleTable->LockD, Irql);			break;		case httNoSynchronization:			break;		default:			ASSERT(FALSE);			break;	}	return;}

BOOLEANxixfs_AcquireResource(	IN BOOLEAN Waitable,	IN PERESOURCE Resource,	IN BOOLEAN IgnoreWait,	IN TYPE_OF_ACQUIRE Type){	BOOLEAN		Wait = FALSE;	BOOLEAN		Acquired = FALSE;	//PAGED_CODE();	DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_RESOURCE,		("Enter xixfs_AcquireResource /n"));	if(!IgnoreWait && Waitable){		Wait = TRUE;	}	switch(Type) {	case AcquireExclusive:		Acquired = ExAcquireResourceExclusiveLite( Resource, Wait );		break;	case AcquireShared:		Acquired = ExAcquireResourceSharedLite( Resource, Wait );		break;	case AcquireSharedStarveExclusive:		Acquired = ExAcquireSharedStarveExclusive( Resource, Wait );	default:		ASSERT(FALSE);		Acquired = FALSE;	}//	if(!Acquired && !IgnoreWait){//		ExRaiseStatus(STATUS_CANT_WAIT);//	}		DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_RESOURCE,		("Exit xixfs_AcquireResource /n"));	return Acquired;}

static BOOLEAN acquire_for_lazy_write(PVOID Context, BOOLEAN Wait) {    PFILE_OBJECT FileObject = Context;    fcb* fcb = FileObject->FsContext;    TRACE("(%p, %u)/n", Context, Wait);    if (!ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, Wait))        return FALSE;    if (!ExAcquireResourceExclusiveLite(fcb->Header.Resource, Wait)) {        ExReleaseResourceLite(&fcb->Vcb->tree_lock);        return FALSE;    }    fcb->lazy_writer_thread = KeGetCurrentThread();    IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);    return TRUE;}