NTSTATUS
VfatFlush(
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;
}
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();
}
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;
}
NTSTATUS
DokanEventRelease(__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;
}
NTSTATUS
DokanFreeFCB(
__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);
}
}
NTSTATUS
DokanFreeCCB(
__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);
}
NTSTATUS
Ext2FlushFiles(
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;
}
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 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();
}
}
VOID
ThreadNotifyCallback (
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();
}
}
NTSTATUS
DokanFilterCallbackAcquireForCreateSection(__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;
}
VOID
FFSFreeCcb(
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());
}
}
static
NTSTATUS
VfatFlushFile(
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
*/
VOID
NTAPI
IoUnregisterFileSystem(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);
}
NTSTATUS
DokanFreeCCB(
__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;
}
PDokanCCB
DokanAllocateCCB(
__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_mustHoldCriticalRegion
NTSTATUS
RfsdPnpCancelRemove (
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_mustHoldCriticalRegion
VOID
FFSFreeMcb(
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());
}
static
NTSTATUS
VfatDismountVolume(
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
*/
VOID
NTAPI
SeLockSubjectContext(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;
}
