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;
}
static
VOID
TestResourceExclusiveAccess(
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();
}
static
VOID
TestResourceSharedAccess(
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;
}
BOOLEAN
CdAcquireForCache (
_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);
}
VOID
FLTAPI
FltUnregisterFilter(_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);
}
BOOLEAN
Ext2FastIoWrite (
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;
}
VOID
DokanCheckKeepAlive(
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;
}
__drv_mustHoldCriticalRegion
FINISHED
FatAcquireSharedVcb (
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 acquire
Return Value:
FINISHED - TRUE if we have the resource and FALSE if we needed to block
for the resource but Wait is FALSE.
--*/
{
PAGED_CODE();
#pragma prefast( suppress: 28137, "prefast wants the wait to be a constant, but that isn't possible for the way fastfat is designed" )
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
PAGEABLE
NTSTATUS
messagetable_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;
}
FINISHED
FatAcquireSharedVcb (
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 acquire
Return 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;
}
BOOLEAN
NTAPI
FatAcquireSharedVcb(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;
}
BOOLEAN
xixfs_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;
}
