mirror of
https://github.com/reactos/reactos.git
synced 2024-09-01 16:18:46 +00:00
![Amine Khaldi](/assets/img/avatar_default.png)
* Create a branch for some evul shell experiments. svn path=/branches/shell-experiments/; revision=61927
376 lines
12 KiB
C
376 lines
12 KiB
C
/*
|
|
* PROJECT: ReactOS Kernel
|
|
* LICENSE: BSD - See COPYING.ARM in the top level directory
|
|
* FILE: ntoskrnl/po/povolume.c
|
|
* PURPOSE: Power Manager DOPE and Volume Management
|
|
* PROGRAMMERS: ReactOS Portable Systems Group
|
|
*/
|
|
|
|
/* INCLUDES ******************************************************************/
|
|
|
|
#include <ntoskrnl.h>
|
|
#define NDEBUG
|
|
#include <debug.h>
|
|
|
|
/* GLOBALS *******************************************************************/
|
|
|
|
typedef struct _POP_FLUSH_VOLUME
|
|
{
|
|
LIST_ENTRY List;
|
|
LONG Count;
|
|
KEVENT Wait;
|
|
} POP_FLUSH_VOLUME, *PPOP_FLUSH_VOLUME;
|
|
|
|
ULONG PopFlushPolicy = 0;
|
|
|
|
KGUARDED_MUTEX PopVolumeLock;
|
|
LIST_ENTRY PopVolumeDevices;
|
|
KSPIN_LOCK PopDopeGlobalLock;
|
|
|
|
/* PRIVATE FUNCTIONS *********************************************************/
|
|
|
|
PDEVICE_OBJECT_POWER_EXTENSION
|
|
NTAPI
|
|
PopGetDope(IN PDEVICE_OBJECT DeviceObject)
|
|
{
|
|
PEXTENDED_DEVOBJ_EXTENSION DeviceExtension;
|
|
PDEVICE_OBJECT_POWER_EXTENSION Dope;
|
|
KIRQL OldIrql;
|
|
PAGED_CODE();
|
|
|
|
/* If the device already has the dope, return it */
|
|
DeviceExtension = IoGetDevObjExtension(DeviceObject);
|
|
if (DeviceExtension->Dope) goto Return;
|
|
|
|
/* Allocate some dope for the device */
|
|
Dope = ExAllocatePoolWithTag(NonPagedPool,
|
|
sizeof(DEVICE_OBJECT_POWER_EXTENSION),
|
|
'Dope');
|
|
if (!Dope) goto Return;
|
|
|
|
/* Initialize the initial contents of the dope */
|
|
RtlZeroMemory(Dope, sizeof(DEVICE_OBJECT_POWER_EXTENSION));
|
|
Dope->DeviceObject = DeviceObject;
|
|
Dope->State = PowerDeviceUnspecified;
|
|
InitializeListHead(&Dope->IdleList);
|
|
|
|
/* Make sure only one caller can assign dope to a device */
|
|
KeAcquireSpinLock(&PopDopeGlobalLock, &OldIrql);
|
|
|
|
/* Make sure the device still has no dope */
|
|
if (!DeviceExtension->Dope)
|
|
{
|
|
/* Give the local dope to this device, and remember we won the race */
|
|
DeviceExtension->Dope = (PVOID)Dope;
|
|
Dope = NULL;
|
|
}
|
|
|
|
/* Allow other dope transactions now */
|
|
KeReleaseSpinLock(&PopDopeGlobalLock, OldIrql);
|
|
|
|
/* Check if someone other than us already assigned the dope, so free ours */
|
|
if (Dope) ExFreePoolWithTag(Dope, 'Dope');
|
|
|
|
/* Return the dope to the caller */
|
|
Return:
|
|
return (PDEVICE_OBJECT_POWER_EXTENSION)DeviceExtension->Dope;
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
PoVolumeDevice(IN PDEVICE_OBJECT DeviceObject)
|
|
{
|
|
PDEVICE_OBJECT_POWER_EXTENSION Dope;
|
|
PAGED_CODE();
|
|
|
|
/* Get dope from the device (if the device has no dope, it will receive some) */
|
|
Dope = PopGetDope(DeviceObject);
|
|
if (Dope)
|
|
{
|
|
/* Make sure we can flush safely */
|
|
KeAcquireGuardedMutex(&PopVolumeLock);
|
|
|
|
/* Add this volume into the list of power-manager volumes */
|
|
if (!Dope->Volume.Flink) InsertTailList(&PopVolumeDevices, &Dope->Volume);
|
|
|
|
/* Allow flushes to go through */
|
|
KeReleaseGuardedMutex(&PopVolumeLock);
|
|
}
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
PoRemoveVolumeDevice(IN PDEVICE_OBJECT DeviceObject)
|
|
{
|
|
PDEVICE_OBJECT_POWER_EXTENSION Dope;
|
|
PEXTENDED_DEVOBJ_EXTENSION DeviceExtension;
|
|
KIRQL OldIrql;
|
|
PAGED_CODE();
|
|
|
|
/* If the device already has the dope, return it */
|
|
DeviceExtension = IoGetDevObjExtension(DeviceObject);
|
|
if (!DeviceExtension->Dope)
|
|
{
|
|
/* no dope */
|
|
return;
|
|
}
|
|
|
|
/* Make sure we can flush safely */
|
|
KeAcquireGuardedMutex(&PopVolumeLock);
|
|
|
|
/* Get dope from device */
|
|
Dope = (PDEVICE_OBJECT_POWER_EXTENSION)DeviceExtension->Dope;
|
|
|
|
if (Dope->Volume.Flink)
|
|
{
|
|
/* Remove from volume from list */
|
|
RemoveEntryList(&Dope->Volume);
|
|
}
|
|
|
|
/* Allow flushes to go through */
|
|
KeReleaseGuardedMutex(&PopVolumeLock);
|
|
|
|
/* Now remove dope from device object */
|
|
KeAcquireSpinLock(&PopDopeGlobalLock, &OldIrql);
|
|
|
|
/* remove from dev obj */
|
|
DeviceExtension->Dope = NULL;
|
|
|
|
/* Release lock */
|
|
KeReleaseSpinLock(&PopDopeGlobalLock, OldIrql);
|
|
|
|
/* Free dope */
|
|
ExFreePoolWithTag(Dope, 'Dope');
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
PopFlushVolumeWorker(IN PVOID Context)
|
|
{
|
|
PPOP_FLUSH_VOLUME FlushContext = (PPOP_FLUSH_VOLUME)Context;
|
|
PDEVICE_OBJECT_POWER_EXTENSION Dope;
|
|
PLIST_ENTRY NextEntry;
|
|
NTSTATUS Status;
|
|
UCHAR Buffer[sizeof(OBJECT_NAME_INFORMATION) + 512];
|
|
POBJECT_NAME_INFORMATION NameInfo = (PVOID)Buffer;
|
|
ULONG Length;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
HANDLE VolumeHandle;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
|
|
/* Acquire the flush lock since we're messing with the list */
|
|
KeAcquireGuardedMutex(&PopVolumeLock);
|
|
|
|
/* Loop the flush list */
|
|
while (!IsListEmpty(&FlushContext->List))
|
|
{
|
|
/* Grab the next (ie: current) entry and remove it */
|
|
NextEntry = FlushContext->List.Flink;
|
|
RemoveEntryList(NextEntry);
|
|
|
|
/* Add it back on the volume list */
|
|
InsertTailList(&PopVolumeDevices, NextEntry);
|
|
|
|
/* Done touching the volume list */
|
|
KeReleaseGuardedMutex(&PopVolumeLock);
|
|
|
|
/* Get the dope from the volume link */
|
|
Dope = CONTAINING_RECORD(NextEntry, DEVICE_OBJECT_POWER_EXTENSION, Volume);
|
|
|
|
/* Get the name */
|
|
Status = ObQueryNameString(Dope->DeviceObject,
|
|
NameInfo,
|
|
sizeof(Buffer),
|
|
&Length);
|
|
if ((NT_SUCCESS(Status)) && (NameInfo->Name.Buffer))
|
|
{
|
|
/* Open the volume */
|
|
DPRINT1("Opening: %wZ\n", &NameInfo->Name);
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&NameInfo->Name,
|
|
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
|
|
0,
|
|
0);
|
|
Status = ZwCreateFile(&VolumeHandle,
|
|
SYNCHRONIZE | FILE_READ_DATA | FILE_WRITE_DATA,
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
NULL,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
FILE_OPEN,
|
|
0,
|
|
NULL,
|
|
0);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* Flush it and close it */
|
|
DPRINT1("Sending flush to: %p\n", VolumeHandle);
|
|
ZwFlushBuffersFile(VolumeHandle, &IoStatusBlock);
|
|
ZwClose(VolumeHandle);
|
|
}
|
|
}
|
|
|
|
/* Acquire the flush lock again since we'll touch the list */
|
|
KeAcquireGuardedMutex(&PopVolumeLock);
|
|
}
|
|
|
|
/* One more flush completed... if it was the last, signal the caller */
|
|
if (!--FlushContext->Count) KeSetEvent(&FlushContext->Wait, IO_NO_INCREMENT, FALSE);
|
|
|
|
/* Serialize with flushers */
|
|
KeReleaseGuardedMutex(&PopVolumeLock);
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
PopFlushVolumes(IN BOOLEAN ShuttingDown)
|
|
{
|
|
POP_FLUSH_VOLUME FlushContext = {{0}};
|
|
ULONG FlushPolicy;
|
|
UNICODE_STRING RegistryName = RTL_CONSTANT_STRING(L"\\Registry");
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
HANDLE RegistryHandle;
|
|
PLIST_ENTRY NextEntry;
|
|
PDEVICE_OBJECT_POWER_EXTENSION Dope;
|
|
ULONG VolumeCount = 0;
|
|
NTSTATUS Status;
|
|
HANDLE ThreadHandle;
|
|
ULONG ThreadCount;
|
|
|
|
/* Setup the flush context */
|
|
InitializeListHead(&FlushContext.List);
|
|
KeInitializeEvent(&FlushContext.Wait, NotificationEvent, FALSE);
|
|
|
|
/* What to flush */
|
|
FlushPolicy = ShuttingDown ? 1 | 2 : PopFlushPolicy;
|
|
if ((FlushPolicy & 1))
|
|
{
|
|
/* Registry flush requested, so open it */
|
|
DPRINT1("Opening registry\n");
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&RegistryName,
|
|
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
|
|
NULL,
|
|
NULL);
|
|
Status = ZwOpenKey(&RegistryHandle, KEY_READ, &ObjectAttributes);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* Flush the registry */
|
|
DPRINT1("Flushing registry\n");
|
|
ZwFlushKey(RegistryHandle);
|
|
ZwClose(RegistryHandle);
|
|
}
|
|
}
|
|
|
|
/* Serialize with other flushes */
|
|
KeAcquireGuardedMutex(&PopVolumeLock);
|
|
|
|
/* Scan the volume list */
|
|
NextEntry = PopVolumeDevices.Flink;
|
|
while (NextEntry != &PopVolumeDevices)
|
|
{
|
|
/* Get the dope from the link */
|
|
Dope = CONTAINING_RECORD(NextEntry, DEVICE_OBJECT_POWER_EXTENSION, Volume);
|
|
|
|
/* Grab the next entry now, since we'll be modifying the list */
|
|
NextEntry = NextEntry->Flink;
|
|
|
|
/* Make sure the object is mounted, writable, exists, and is not a floppy */
|
|
if (!(Dope->DeviceObject->Vpb->Flags & VPB_MOUNTED) ||
|
|
(Dope->DeviceObject->Characteristics & FILE_FLOPPY_DISKETTE) ||
|
|
(Dope->DeviceObject->Characteristics & FILE_READ_ONLY_DEVICE) ||
|
|
((Dope->DeviceObject->Vpb->RealDevice) &&
|
|
(Dope->DeviceObject->Vpb->RealDevice->Characteristics & FILE_FLOPPY_DISKETTE)))
|
|
{
|
|
/* Not flushable */
|
|
continue;
|
|
}
|
|
|
|
/* Remove it from the dope and add it to the flush context list */
|
|
RemoveEntryList(&Dope->Volume);
|
|
InsertTailList(&FlushContext.List, &Dope->Volume);
|
|
|
|
/* Next */
|
|
VolumeCount++;
|
|
}
|
|
|
|
/* Check if we should skip non-removable devices */
|
|
if (!(FlushPolicy & 2))
|
|
{
|
|
/* ReactOS only implements this routine for shutdown, which requires it */
|
|
UNIMPLEMENTED_DBGBREAK();
|
|
}
|
|
|
|
/* Check if there were no volumes at all */
|
|
if (!VolumeCount)
|
|
{
|
|
/* Nothing to do */
|
|
KeReleaseGuardedMutex(&PopVolumeLock);
|
|
return;
|
|
}
|
|
|
|
/* Allocate up to 8 flusher threads */
|
|
ThreadCount = min(VolumeCount, 8);
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
NULL,
|
|
OBJ_KERNEL_HANDLE,
|
|
NULL,
|
|
NULL);
|
|
|
|
/* We will ourselves become a flusher thread */
|
|
FlushContext.Count = 1;
|
|
ThreadCount--;
|
|
|
|
/* Look for any extra ones we might need */
|
|
while (ThreadCount > 0)
|
|
{
|
|
/* Create a new one */
|
|
ThreadCount--;
|
|
DPRINT1("Creating flush thread\n");
|
|
Status = PsCreateSystemThread(&ThreadHandle,
|
|
THREAD_ALL_ACCESS,
|
|
&ObjectAttributes,
|
|
0L,
|
|
NULL,
|
|
PopFlushVolumeWorker,
|
|
&FlushContext);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* One more created... */
|
|
FlushContext.Count++;
|
|
ZwClose(ThreadHandle);
|
|
}
|
|
}
|
|
|
|
/* Allow flushes to go through */
|
|
KeReleaseGuardedMutex(&PopVolumeLock);
|
|
|
|
/* Enter the flush work */
|
|
DPRINT1("Local flush\n");
|
|
PopFlushVolumeWorker(&FlushContext);
|
|
|
|
/* Wait for all flushes to be over */
|
|
DPRINT1("Waiting for flushes\n");
|
|
KeWaitForSingleObject(&FlushContext.Wait, Executive, KernelMode, FALSE, NULL);
|
|
DPRINT1("Flushes have completed\n");
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
PoInitializeDeviceObject(IN OUT PDEVOBJ_EXTENSION DeviceObjectExtension)
|
|
{
|
|
PEXTENDED_DEVOBJ_EXTENSION DeviceExtension = (PVOID)DeviceObjectExtension;
|
|
PAGED_CODE();
|
|
|
|
/* Initialize the power flags */
|
|
DeviceExtension->PowerFlags = PowerSystemUnspecified & 0xF;
|
|
DeviceExtension->PowerFlags |= ((PowerDeviceUnspecified << 4) & 0xF0);
|
|
|
|
/* The device object is not on drugs yet */
|
|
DeviceExtension->Dope = NULL;
|
|
}
|
|
|
|
/* PUBLIC FUNCTIONS **********************************************************/
|
|
|