[ros-diffs] [pschweitzer] 52065: [NTOSKRNL] - renamed Io volumes global to match Windows names (in case of debug) - renamed IopDereferenceVpb() to IopDereferenceVpbAndFree(), IopReferenceVpbForVerify() to IopR...

Author: pschweitzer
Date: Thu Jun  2 17:43:44 2011
New Revision: 52065

URL: http://svn.reactos.org/svn/reactos?rev=52065&view=rev
Log:
[NTOSKRNL]
- renamed Io volumes global to match Windows names (in case of debug)
- renamed IopDereferenceVpb() to IopDereferenceVpbAndFree(), IopReferenceVpbForVerify() to
IopReferenceVerifyVpb(), IopInitializeVpbForMount() to IopMountInitializeVpb(),
IopLoadFileSystem() to IopLoadFileSystemDriver()
- implemented IopDecrementDeviceObjectHandleCount(), IopInterlockedIncrementUlong(),
IopInterlockedDecrementUlong(), IopNotifyAlreadyRegisteredFileSystems() and
IoEnumerateRegisteredFiltersList()
- halfplemented IopDecrementDeviceObjectRef()
- implemented check for already registrered notification in
IoRegisterFsRegistrationChange()
- implemented sending notifications for already registered drivers to registrant in
IoRegisterFsRegistrationChange()
- implemented VPB freeing in IopDereferenceVpbAndFree()
- acquire Io volumes lists once and forever for system shutdown, instead of keeping
acquiring and releasing
- reference device object in IopShutdownBaseFileSystems() before sending it the shutdown
IRP. To ensure to keep it valid till the end
- added a FS driver registration operations counter
- use this counter to handle failed mounts
- fixed: release locks before calling driver for mounting and reacquire them after
- fixed check for boot partition failure (and associated bugcheck): check we are in boot
phase 0 or 1
- simplified lock process by using only one lock (ie removed mutex). Also use only
critical region where needed
- fixed: ensure that locks are properly released when quitting a function
- fixed wrong return in IopCreateVpb()
- minor fixes around

Modified:
    trunk/reactos/ntoskrnl/include/internal/io.h
    trunk/reactos/ntoskrnl/io/iomgr/device.c
    trunk/reactos/ntoskrnl/io/iomgr/file.c
    trunk/reactos/ntoskrnl/io/iomgr/iomgr.c
    trunk/reactos/ntoskrnl/io/iomgr/volume.c

Modified: trunk/reactos/ntoskrnl/include/internal/io.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/include/internal/…
==============================================================================
--- trunk/reactos/ntoskrnl/include/internal/io.h [iso-8859-1] (original)
+++ trunk/reactos/ntoskrnl/include/internal/io.h [iso-8859-1] Thu Jun  2 17:43:44 2011
@@ -838,7 +838,7 @@
 
 VOID
 NTAPI
-IopDereferenceVpb(
+IopDereferenceVpbAndFree(
     IN PVPB Vpb
 );
 
@@ -869,8 +869,15 @@
 
 NTSTATUS
 NTAPI
-IoGetRelatedTargetDevice(IN PFILE_OBJECT FileObject,
-                         OUT PDEVICE_OBJECT *DeviceObject
+IoGetRelatedTargetDevice(
+    IN PFILE_OBJECT FileObject,
+    OUT PDEVICE_OBJECT *DeviceObject
+);
+
+VOID
+NTAPI
+IopUnloadDevice(
+    IN PDEVICE_OBJECT DeviceObject
 );
 
 //

Modified: trunk/reactos/ntoskrnl/io/iomgr/device.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/io/iomgr/device.c…
==============================================================================
--- trunk/reactos/ntoskrnl/io/iomgr/device.c [iso-8859-1] (original)
+++ trunk/reactos/ntoskrnl/io/iomgr/device.c [iso-8859-1] Thu Jun  2 17:43:44 2011
@@ -19,9 +19,10 @@
 ULONG IopDeviceObjectNumber = 0;
 LIST_ENTRY ShutdownListHead, LastChanceShutdownListHead;
 KSPIN_LOCK ShutdownListLock;
-extern LIST_ENTRY IopDiskFsListHead;
-extern LIST_ENTRY IopCdRomFsListHead;
-extern LIST_ENTRY IopTapeFsListHead;
+extern LIST_ENTRY IopDiskFileSystemQueueHead;
+extern LIST_ENTRY IopCdRomFileSystemQueueHead;
+extern LIST_ENTRY IopTapeFileSystemQueueHead;
+extern ERESOURCE IopDatabaseResource;
 
 /* PRIVATE FUNCTIONS **********************************************************/
 
@@ -187,14 +188,17 @@
     }
     else if (Phase == 1)
     {
+        /* Acquire resource forever */
+        ExAcquireResourceExclusiveLite(&IopDatabaseResource, TRUE);
+
         /* Shutdown disk file systems */
-        IopShutdownBaseFileSystems(&IopDiskFsListHead);
+        IopShutdownBaseFileSystems(&IopDiskFileSystemQueueHead);
 
         /* Shutdown cdrom file systems */
-        IopShutdownBaseFileSystems(&IopCdRomFsListHead);
+        IopShutdownBaseFileSystems(&IopCdRomFileSystemQueueHead);
 
         /* Shutdown tape filesystems */
-        IopShutdownBaseFileSystems(&IopTapeFsListHead);
+        IopShutdownBaseFileSystems(&IopTapeFileSystemQueueHead);
         
         /* Loop last-chance shutdown notifications */
         ListEntry = ExInterlockedRemoveHeadList(&LastChanceShutdownListHead,

Modified: trunk/reactos/ntoskrnl/io/iomgr/file.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/io/iomgr/file.c?r…
==============================================================================
--- trunk/reactos/ntoskrnl/io/iomgr/file.c [iso-8859-1] (original)
+++ trunk/reactos/ntoskrnl/io/iomgr/file.c [iso-8859-1] Thu Jun  2 17:43:44 2011
@@ -479,7 +479,7 @@
     {
         /* Dereference the device and VPB, then fail */
         IopDereferenceDeviceObject(OriginalDeviceObject, FALSE);
-        if (Vpb) IopDereferenceVpb(Vpb);
+        if (Vpb) IopDereferenceVpbAndFree(Vpb);
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
@@ -577,7 +577,7 @@
 
             /* Dereference the device and VPB */
             IopDereferenceDeviceObject(OriginalDeviceObject, FALSE);
-            if (Vpb) IopDereferenceVpb(Vpb);
+            if (Vpb) IopDereferenceVpbAndFree(Vpb);
 
             /* We failed, return status */
             OpenPacket->FinalStatus = Status;
@@ -687,7 +687,7 @@
 
             /* Dereference the device object and VPB */
             IopDereferenceDeviceObject(OriginalDeviceObject, FALSE);
-            if (Vpb) IopDereferenceVpb(Vpb);
+            if (Vpb) IopDereferenceVpbAndFree(Vpb);
 
             /* Clear the FO and dereference it */
             FileObject->DeviceObject = NULL;
@@ -783,7 +783,7 @@
         IopDereferenceDeviceObject(OriginalDeviceObject, FALSE);
 
         /* Unless the driver cancelled the open, dereference the VPB */
-        if (!(OpenCancelled) && (Vpb)) IopDereferenceVpb(Vpb);
+        if (!(OpenCancelled) && (Vpb)) IopDereferenceVpbAndFree(Vpb);
 
         /* Set the status and return */
         OpenPacket->FinalStatus = Status;
@@ -806,7 +806,7 @@
     if (OwnerDevice != DeviceObject)
     {
         /* We have to de-reference the VPB we had associated */
-        if (Vpb) IopDereferenceVpb(Vpb);
+        if (Vpb) IopDereferenceVpbAndFree(Vpb);
 
         /* And re-associate with the actual one */
         Vpb = FileObject->Vpb;

Modified: trunk/reactos/ntoskrnl/io/iomgr/iomgr.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/io/iomgr/iomgr.c?…
==============================================================================
--- trunk/reactos/ntoskrnl/io/iomgr/iomgr.c [iso-8859-1] (original)
+++ trunk/reactos/ntoskrnl/io/iomgr/iomgr.c [iso-8859-1] Thu Jun  2 17:43:44 2011
@@ -52,19 +52,17 @@
 extern LIST_ENTRY LastChanceShutdownListHead;
 extern KSPIN_LOCK ShutdownListLock;
 extern POBJECT_TYPE IoAdapterObjectType;
-ERESOURCE IopDatabaseResource;
-extern ERESOURCE FileSystemListLock;
+extern ERESOURCE IopDatabaseResource;
 ERESOURCE IopSecurityResource;
-extern KGUARDED_MUTEX FsChangeNotifyListLock;
 extern KGUARDED_MUTEX PnpNotifyListLock;
-extern LIST_ENTRY IopDiskFsListHead;
-extern LIST_ENTRY IopCdRomFsListHead;
-extern LIST_ENTRY IopTapeFsListHead;
-extern LIST_ENTRY IopNetworkFsListHead;
+extern LIST_ENTRY IopDiskFileSystemQueueHead;
+extern LIST_ENTRY IopCdRomFileSystemQueueHead;
+extern LIST_ENTRY IopTapeFileSystemQueueHead;
+extern LIST_ENTRY IopNetworkFileSystemQueueHead;
 extern LIST_ENTRY DriverBootReinitListHead;
 extern LIST_ENTRY DriverReinitListHead;
 extern LIST_ENTRY PnpNotifyListHead;
-extern LIST_ENTRY FsChangeNotifyListHead;
+extern LIST_ENTRY IopFsNotifyChangeQueueHead;
 extern LIST_ENTRY IopErrorLogListHead;
 extern LIST_ENTRY IopTimerQueueHead;
 extern KDPC IopTimerDpc;
@@ -450,20 +448,18 @@
 
     /* Initialize all locks and lists */
     ExInitializeResource(&IopDatabaseResource);
-    ExInitializeResource(&FileSystemListLock);
     ExInitializeResource(&IopSecurityResource);
-    KeInitializeGuardedMutex(&FsChangeNotifyListLock);
     KeInitializeGuardedMutex(&PnpNotifyListLock);
-    InitializeListHead(&IopDiskFsListHead);
-    InitializeListHead(&IopCdRomFsListHead);
-    InitializeListHead(&IopTapeFsListHead);
-    InitializeListHead(&IopNetworkFsListHead);
+    InitializeListHead(&IopDiskFileSystemQueueHead);
+    InitializeListHead(&IopCdRomFileSystemQueueHead);
+    InitializeListHead(&IopTapeFileSystemQueueHead);
+    InitializeListHead(&IopNetworkFileSystemQueueHead);
     InitializeListHead(&DriverBootReinitListHead);
     InitializeListHead(&DriverReinitListHead);
     InitializeListHead(&PnpNotifyListHead);
     InitializeListHead(&ShutdownListHead);
     InitializeListHead(&LastChanceShutdownListHead);
-    InitializeListHead(&FsChangeNotifyListHead);
+    InitializeListHead(&IopFsNotifyChangeQueueHead);
     InitializeListHead(&IopErrorLogListHead);
     KeInitializeSpinLock(&IoStatisticsLock);
     KeInitializeSpinLock(&DriverReinitListLock);

Modified: trunk/reactos/ntoskrnl/io/iomgr/volume.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/io/iomgr/volume.c…
==============================================================================
--- trunk/reactos/ntoskrnl/io/iomgr/volume.c [iso-8859-1] (original)
+++ trunk/reactos/ntoskrnl/io/iomgr/volume.c [iso-8859-1] Thu Jun  2 17:43:44 2011
@@ -6,6 +6,7 @@
  * PROGRAMMERS:     Alex Ionescu (alex.ionescu(a)reactos.org)
  *                  Hervé Poussineau (hpoussin(a)reactos.org)
  *                  Eric Kohl
+ *                  Pierre Schweitzer (pierre.schweitzer(a)reactos.org)
  */
 
 /* INCLUDES *****************************************************************/
@@ -21,14 +22,60 @@
 
 /* GLOBALS ******************************************************************/
 
-ERESOURCE FileSystemListLock;
-LIST_ENTRY IopDiskFsListHead, IopNetworkFsListHead;
-LIST_ENTRY IopCdRomFsListHead, IopTapeFsListHead;
-KGUARDED_MUTEX FsChangeNotifyListLock;
-LIST_ENTRY FsChangeNotifyListHead;
+ERESOURCE IopDatabaseResource;
+LIST_ENTRY IopDiskFileSystemQueueHead, IopNetworkFileSystemQueueHead;
+LIST_ENTRY IopCdRomFileSystemQueueHead, IopTapeFileSystemQueueHead;
+LIST_ENTRY IopFsNotifyChangeQueueHead;
+ULONG IopFsRegistrationOps;
 
 /* PRIVATE FUNCTIONS *********************************************************/
 
+/*
+ * @halfplemented
+ */
+VOID
+NTAPI
+IopDecrementDeviceObjectRef(IN PDEVICE_OBJECT DeviceObject,
+                            IN BOOLEAN UnloadIfUnused)
+{
+    KIRQL OldIrql;
+
+    /* Acquire lock */
+    OldIrql = KeAcquireQueuedSpinLock(LockQueueIoDatabaseLock);
+    ASSERT(DeviceObject->ReferenceCount > 0);
+
+    if (--DeviceObject->ReferenceCount > 0)
+    {
+        KeReleaseQueuedSpinLock(LockQueueIoDatabaseLock, OldIrql);
+        return;
+    }
+
+    /* Here, DO is not referenced any longer, check if we have to unload it */
+    if (UnloadIfUnused || IoGetDevObjExtension(DeviceObject)->ExtensionFlags &
+                          (DOE_UNLOAD_PENDING | DOE_DELETE_PENDING |
DOE_REMOVE_PENDING))
+    {
+        /* Unload the driver */
+        IopUnloadDevice(DeviceObject);
+    }
+
+    /* Release lock */
+    KeReleaseQueuedSpinLock(LockQueueIoDatabaseLock, OldIrql);
+}
+
+/*
+ * @implemented
+ */
+VOID
+NTAPI
+IopDecrementDeviceObjectHandleCount(IN PDEVICE_OBJECT DeviceObject)
+{
+    /* Just decrease reference count */
+    IopDecrementDeviceObjectRef(DeviceObject, FALSE);
+}
+
+/*
+ * @implemented
+ */
 PVPB
 NTAPI
 IopCheckVpbMounted(IN POPEN_PACKET OpenPacket,
@@ -100,6 +147,9 @@
     return Vpb;
 }
 
+/*
+ * @implemented
+ */
 NTSTATUS
 NTAPI
 IopCreateVpb(IN PDEVICE_OBJECT DeviceObject)
@@ -110,7 +160,7 @@
     Vpb = ExAllocatePoolWithTag(NonPagedPool,
                                 sizeof(VPB),
                                 TAG_VPB);
-    if (!Vpb) return STATUS_UNSUCCESSFUL;
+    if (!Vpb) return STATUS_INSUFFICIENT_RESOURCES;
 
     /* Clear it so we don't waste time manually */
     RtlZeroMemory(Vpb, sizeof(VPB));
@@ -125,9 +175,12 @@
     return STATUS_SUCCESS;
 }
 
+/*
+ * @implemented
+ */
 VOID
 NTAPI
-IopDereferenceVpb(IN PVPB Vpb)
+IopDereferenceVpbAndFree(IN PVPB Vpb)
 {
     KIRQL OldIrql;
 
@@ -136,21 +189,30 @@
     Vpb->ReferenceCount--;
 
     /* Check if we're out of references */
-    if (!Vpb->ReferenceCount)
-    {
-        /* FIXME: IMPLEMENT CLEANUP! */
-        ASSERT(FALSE);
-    }
-
-    /* Release VPB lock */
-    IoReleaseVpbSpinLock(OldIrql);
-}
-
+    if (!Vpb->ReferenceCount && Vpb->RealDevice->Vpb == Vpb &&
+        !(Vpb->Flags & VPB_PERSISTENT))
+    {
+        /* Release VPB lock */
+        IoReleaseVpbSpinLock(OldIrql);
+
+        /* And free VPB */
+        ExFreePoolWithTag(Vpb, TAG_VPB);
+    }
+    else
+    {
+        /* Release VPB lock */
+        IoReleaseVpbSpinLock(OldIrql);
+    }
+}
+
+/*
+ * @implemented
+ */
 BOOLEAN
 NTAPI
-IopReferenceVpbForVerify(IN PDEVICE_OBJECT DeviceObject,
-                         OUT PDEVICE_OBJECT *FileSystemObject,
-                         OUT PVPB *Vpb)
+IopReferenceVerifyVpb(IN PDEVICE_OBJECT DeviceObject,
+                      OUT PDEVICE_OBJECT *FileSystemObject,
+                      OUT PVPB *Vpb)
 {
     KIRQL OldIrql;
     PVPB LocalVpb;
@@ -181,9 +243,9 @@
 
 PVPB
 NTAPI
-IopInitializeVpbForMount(IN PDEVICE_OBJECT DeviceObject,
-                         IN PDEVICE_OBJECT AttachedDeviceObject,
-                         IN BOOLEAN Raw)
+IopMountInitializeVpb(IN PDEVICE_OBJECT DeviceObject,
+                      IN PDEVICE_OBJECT AttachedDeviceObject,
+                      IN BOOLEAN Raw)
 {
     KIRQL OldIrql;
     PVPB Vpb;
@@ -212,20 +274,20 @@
     return Vpb;
 }
 
+/*
+ * @implemented
+ */
 VOID
-NTAPI
+FORCEINLINE
 IopNotifyFileSystemChange(IN PDEVICE_OBJECT DeviceObject,
                           IN BOOLEAN DriverActive)
 {
     PFS_CHANGE_NOTIFY_ENTRY ChangeEntry;
     PLIST_ENTRY ListEntry;
 
-    /* Acquire the notification lock */
-    KeAcquireGuardedMutex(&FsChangeNotifyListLock);
-
     /* Loop the list */
-    ListEntry = FsChangeNotifyListHead.Flink;
-    while (ListEntry != &FsChangeNotifyListHead)
+    ListEntry = IopFsNotifyChangeQueueHead.Flink;
+    while (ListEntry != &IopFsNotifyChangeQueueHead)
     {
         /* Get the entry */
         ChangeEntry = CONTAINING_RECORD(ListEntry,
@@ -238,11 +300,47 @@
         /* Go to the next entry */
         ListEntry = ListEntry->Flink;
     }
-
-    /* Release the lock */
-    KeReleaseGuardedMutex(&FsChangeNotifyListLock);
-}
-
+}
+
+/*
+ * @implemented
+ */
+ULONG
+FASTCALL
+IopInterlockedIncrementUlong(IN KSPIN_LOCK_QUEUE_NUMBER Queue,
+                             IN PULONG Ulong)
+{
+    KIRQL Irql;
+    ULONG OldValue;
+
+    Irql = KeAcquireQueuedSpinLock(Queue);
+    OldValue = (*Ulong)++;
+    KeReleaseQueuedSpinLock(Queue, Irql);
+
+    return OldValue;
+}
+
+/*
+ * @implemented
+ */
+ULONG
+FASTCALL
+IopInterlockedDecrementUlong(IN KSPIN_LOCK_QUEUE_NUMBER Queue,
+                             IN PULONG Ulong)
+{
+    KIRQL Irql;
+    ULONG OldValue;
+
+    Irql = KeAcquireQueuedSpinLock(Queue);
+    OldValue = (*Ulong)--;
+    KeReleaseQueuedSpinLock(Queue, Irql);
+
+    return OldValue;
+}
+
+/*
+ * @implemented
+ */
 VOID
 NTAPI
 IopShutdownBaseFileSystems(IN PLIST_ENTRY ListHead)
@@ -254,9 +352,6 @@
     KEVENT Event;
     NTSTATUS Status;
 
-    /* Lock the FS List and initialize an event to wait on */
-    KeEnterCriticalRegion();
-    ExAcquireResourceSharedLite(&FileSystemListLock,TRUE);
     KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
     /* Get the first entry and start looping */
@@ -267,6 +362,9 @@
         DeviceObject = CONTAINING_RECORD(ListEntry,
                                          DEVICE_OBJECT,
                                          Queue.ListEntry);
+
+        ObReferenceObject(DeviceObject);
+        IopInterlockedIncrementUlong(LockQueueIoDatabaseLock,
(PULONG)&DeviceObject->ReferenceCount);
 
         /* Check if we're attached */
         if (DeviceObject->AttachedDevice)
@@ -293,18 +391,20 @@
         /* Reset the event */
         KeClearEvent(&Event);
 
+        IopDecrementDeviceObjectRef(DeviceObject, FALSE);
+        ObDereferenceObject(DeviceObject);
+
         /* Go to the next entry */
         ListEntry = ListEntry->Flink;
     }
-
-    /* Release the lock */
-    ExReleaseResourceLite(&FileSystemListLock);
-    KeLeaveCriticalRegion();
-}
-
+}
+
+/*
+ * @implemented
+ */
 VOID
 NTAPI
-IopLoadFileSystem(IN PDEVICE_OBJECT DeviceObject)
+IopLoadFileSystemDriver(IN PDEVICE_OBJECT DeviceObject)
 {
     IO_STATUS_BLOCK IoStatusBlock;
     PIO_STACK_LOCATION StackPtr;
@@ -347,8 +447,14 @@
             KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
         }
     }
-}
-
+
+    /* Dereference DO - FsRec? */
+    IopDecrementDeviceObjectRef(AttachedDeviceObject, TRUE);
+}
+
+/*
+ * @implemented
+ */
 NTSTATUS
 NTAPI
 IopMountVolume(IN PDEVICE_OBJECT DeviceObject,
@@ -366,7 +472,7 @@
     LIST_ENTRY LocalList;
     PDEVICE_OBJECT AttachedDeviceObject = DeviceObject;
     PDEVICE_OBJECT FileSystemDeviceObject, ParentFsDeviceObject;
-    ULONG FsStackOverhead;
+    ULONG FsStackOverhead, RegistrationOps;
     PAGED_CODE();
 
     /* Check if the device isn't already locked */
@@ -387,7 +493,7 @@
 
     /* Acquire the FS Lock*/
     KeEnterCriticalRegion();
-    ExAcquireResourceSharedLite(&FileSystemListLock, TRUE);
+    ExAcquireResourceSharedLite(&IopDatabaseResource, TRUE);
 
     /* Make sure we weren't already mounted */
     if (!(DeviceObject->Vpb->Flags & (VPB_MOUNTED | VPB_REMOVE_PENDING)))
@@ -411,17 +517,17 @@
             (DeviceObject->DeviceType == FILE_DEVICE_VIRTUAL_DISK))
         {
             /* Use the disk list */
-            FsList = &IopDiskFsListHead;
+            FsList = &IopDiskFileSystemQueueHead;
         }
         else if (DeviceObject->DeviceType == FILE_DEVICE_CD_ROM)
         {
             /* Use the CD-ROM list */
-            FsList = &IopCdRomFsListHead;
+            FsList = &IopCdRomFileSystemQueueHead;
         }
         else
         {
             /* It's gotta be a tape... */
-            FsList = &IopTapeFsListHead;
+            FsList = &IopTapeFileSystemQueueHead;
         }
 
         /* Now loop the fs list until one of the file systems accepts us */
@@ -502,6 +608,13 @@
             StackPtr->Parameters.MountVolume.DeviceObject =
                 AttachedDeviceObject;
 
+            /* Save registration operations */
+            RegistrationOps = IopFsRegistrationOps;
+
+            /* Release locks */
+            IopInterlockedIncrementUlong(LockQueueIoDatabaseLock,
(PULONG)&DeviceObject->ReferenceCount);
+            ExReleaseResourceLite(&IopDatabaseResource);
+
             /* Call the driver */
             Status = IoCallDriver(FileSystemDeviceObject, Irp);
             if (Status == STATUS_PENDING)
@@ -515,14 +628,17 @@
                 Status = IoStatusBlock.Status;
             }
 
+            ExAcquireResourceSharedLite(&IopDatabaseResource, TRUE);
+            IopInterlockedDecrementUlong(LockQueueIoDatabaseLock,
(PULONG)&DeviceObject->ReferenceCount);
+
             /* Check if mounting was successful */
             if (NT_SUCCESS(Status))
             {
                 /* Mount the VPB */
-                *Vpb = IopInitializeVpbForMount(DeviceObject,
-                                                AttachedDeviceObject,
-                                                (DeviceObject->Vpb->Flags &
-                                                 VPB_RAW_MOUNT));
+                *Vpb = IopMountInitializeVpb(DeviceObject,
+                                             AttachedDeviceObject,
+                                             (DeviceObject->Vpb->Flags &
+                                              VPB_RAW_MOUNT));
             }
             else
             {
@@ -534,11 +650,22 @@
                     break;
                 }
 
+                /* If there were registration operations in the meanwhile */
+                if (RegistrationOps != IopFsRegistrationOps)
+                {
+                    /* We need to setup a local list to pickup where we left */
+                    LocalList.Flink = FsList->Flink;
+                    ListEntry = &LocalList;
+
+                    Status = STATUS_UNRECOGNIZED_VOLUME;
+                }
+
                 /* Otherwise, check if we need to load the FS driver */
                 if (Status == STATUS_FS_DRIVER_REQUIRED)
                 {
                     /* We need to release the lock */
-                    ExReleaseResourceLite(&FileSystemListLock);
+                    IopInterlockedIncrementUlong(LockQueueIoDatabaseLock,
(PULONG)&DeviceObject->ReferenceCount);
+                    ExReleaseResourceLite(&IopDatabaseResource);
 
                     /* Release the device lock if we're holding it */
                     if (!DeviceIsLocked)
@@ -546,8 +673,11 @@
                         KeSetEvent(&DeviceObject->DeviceLock, 0, FALSE);
                     }
 
+                    /* Leave critical section */
+                    KeLeaveCriticalRegion();
+
                     /* Load the FS */
-                    IopLoadFileSystem(ParentFsDeviceObject);
+                    IopLoadFileSystemDriver(ParentFsDeviceObject);
 
                     /* Check if the device isn't already locked */
                     if (!DeviceIsLocked)
@@ -569,7 +699,8 @@
                     }
 
                     /* Reacquire the lock */
-                    ExAcquireResourceSharedLite(&FileSystemListLock, TRUE);
+                    KeEnterCriticalRegion();
+                    ExAcquireResourceSharedLite(&IopDatabaseResource, TRUE);
 
                     /* When we released the lock, make sure nobody beat us */
                     if (DeviceObject->Vpb->Flags & VPB_MOUNTED)
@@ -620,7 +751,7 @@
     }
 
     /* Release the FS lock */
-    ExReleaseResourceLite(&FileSystemListLock);
+    ExReleaseResourceLite(&IopDatabaseResource);
     KeLeaveCriticalRegion();
 
     /* Release the device lock if we're holding it */
@@ -628,7 +759,8 @@
 
     /* Check if we failed to mount the boot partition */
     if ((!NT_SUCCESS(Status)) &&
-        (DeviceObject->Flags & DO_SYSTEM_BOOT_PARTITION))
+        (DeviceObject->Flags & DO_SYSTEM_BOOT_PARTITION) &&
+        ExpInitializationPhase < 2)
     {
         /* Bugcheck the system */
         KeBugCheckEx(INACCESSIBLE_BOOT_DEVICE,
@@ -642,19 +774,102 @@
     return Status;
 }
 
+/*
+ * @implemented
+ */
+VOID
+NTAPI
+IopNotifyAlreadyRegisteredFileSystems(IN PLIST_ENTRY ListHead,
+                                      IN PDRIVER_FS_NOTIFICATION
DriverNotificationRoutine,
+                                      BOOLEAN SkipLast)
+{
+    PLIST_ENTRY ListEntry;
+    PDEVICE_OBJECT DeviceObject;
+
+    /* Browse the whole list */
+    ListEntry = ListHead->Flink;
+    while (ListEntry != ListHead)
+    {
+        /* Check if we reached end and if we have to skip it */
+        if (ListEntry->Flink == ListHead && SkipLast)
+        {
+            return;
+        }
+
+        /* Otherwise, get DO and notify */
+        DeviceObject = CONTAINING_RECORD(ListEntry,
+                                         DEVICE_OBJECT,
+                                         Queue.ListEntry);
+
+        DriverNotificationRoutine(DeviceObject, TRUE);
+
+        /* Go to the next entry */
+        ListEntry = ListEntry->Flink;
+    }
+}
+
 /* PUBLIC FUNCTIONS **********************************************************/
 
 /*
- * @unimplemented
+ * @implemented
  */
 NTSTATUS
 NTAPI
-IoEnumerateRegisteredFiltersList(IN PDRIVER_OBJECT *DriverObjectList,
+IoEnumerateRegisteredFiltersList(OUT PDRIVER_OBJECT *DriverObjectList,
                                  IN ULONG DriverObjectListSize,
                                  OUT PULONG ActualNumberDriverObjects)
 {
-    UNIMPLEMENTED;
-    return STATUS_UNSUCCESSFUL;
+    USHORT Index = 0;
+    ULONG ListSize = 0;
+    PLIST_ENTRY ListEntry;
+    NTSTATUS Status = STATUS_SUCCESS;
+    PFS_CHANGE_NOTIFY_ENTRY ChangeEntry;
+
+    /* Acquire the FS lock */
+    ExAcquireResourceExclusiveLite(&IopDatabaseResource, TRUE);
+
+    /* First of all, count number of driver objects */
+    ListEntry = IopFsNotifyChangeQueueHead.Flink;
+    while (ListEntry != &IopFsNotifyChangeQueueHead)
+    {
+        ListSize++;
+
+        /* Go to the next entry */
+        ListEntry = ListEntry->Flink;
+    }
+
+    /* Return this size */
+    *ActualNumberDriverObjects = ListSize;
+
+    /* Then, check if given buffer is big enough to contain list */
+    if (ListSize > DriverObjectListSize / sizeof(PDRIVER_OBJECT))
+    {
+        Status = STATUS_BUFFER_TOO_SMALL;
+    }
+    else
+    {
+        /* Rebrowse the whole list */
+        ListEntry = IopFsNotifyChangeQueueHead.Flink;
+        while (ListEntry != &IopFsNotifyChangeQueueHead)
+        {
+            ChangeEntry = CONTAINING_RECORD(ListEntry,
+                                            FS_CHANGE_NOTIFY_ENTRY,
+                                            FsChangeNotifyList);
+
+            /* Reference the driver object */
+            ObReferenceObject(ChangeEntry->DriverObject);
+            /* And pass it to the caller */
+            DriverObjectList[Index++] = ChangeEntry->DriverObject;
+
+            /* Go to the next entry */
+            ListEntry = ListEntry->Flink;
+        }
+    }
+
+    /* Release the FS lock */
+    ExReleaseResourceLite(&IopDatabaseResource);
+
+    return Status;
 }
 
 /*
@@ -669,20 +884,21 @@
     PIO_STACK_LOCATION StackPtr;
     KEVENT Event;
     PIRP Irp;
-    NTSTATUS Status = STATUS_SUCCESS, VpbStatus;
+    NTSTATUS Status, VpbStatus;
     PDEVICE_OBJECT FileSystemDeviceObject;
     PVPB Vpb, NewVpb;
     BOOLEAN WasNotMounted = TRUE;
 
     /* Wait on the device lock */
-    KeWaitForSingleObject(&DeviceObject->DeviceLock,
-                          Executive,
-                          KernelMode,
-                          FALSE,
-                          NULL);
+    Status = KeWaitForSingleObject(&DeviceObject->DeviceLock,
+                                   Executive,
+                                   KernelMode,
+                                   FALSE,
+                                   NULL);
+    ASSERT(Status == STATUS_SUCCESS);
 
     /* Reference the VPB */
-    if (IopReferenceVpbForVerify(DeviceObject, &FileSystemDeviceObject, &Vpb))
+    if (IopReferenceVerifyVpb(DeviceObject, &FileSystemDeviceObject, &Vpb))
     {
         /* Initialize the event */
         KeInitializeEvent(&Event, NotificationEvent, FALSE);
@@ -698,7 +914,11 @@
 
         /* Allocate the IRP */
         Irp = IoAllocateIrp(FileSystemDeviceObject->StackSize, FALSE);
-        if (!Irp) return STATUS_INSUFFICIENT_RESOURCES;
+        if (!Irp)
+        {
+            Status = STATUS_INSUFFICIENT_RESOURCES;
+            goto Release;
+        }
 
         /* Set it up */
         Irp->UserIosb = &IoStatusBlock;
@@ -726,28 +946,37 @@
         }
 
         /* Dereference the VPB */
-        IopDereferenceVpb(Vpb);
+        IopDereferenceVpbAndFree(Vpb);
     }
 
     /* Check if we had the wrong volume or didn't mount at all */
-    if ((Status == STATUS_WRONG_VOLUME) || (WasNotMounted))
+    if (Status == STATUS_WRONG_VOLUME)
     {
         /* Create a VPB */
         VpbStatus = IopCreateVpb(DeviceObject);
         if (NT_SUCCESS(VpbStatus))
         {
+            PoVolumeDevice(DeviceObject);
+
             /* Mount it */
             VpbStatus = IopMountVolume(DeviceObject,
                                        AllowRawMount,
                                        TRUE,
                                        FALSE,
                                        &NewVpb);
+
+            /* If we got a new VPB, dereference it */
+            if (NewVpb)
+            {
+                IopInterlockedDecrementUlong(LockQueueIoVpbLock,
&NewVpb->ReferenceCount);
+            }
         }
 
         /* If we failed, remove the verify flag */
         if (!NT_SUCCESS(VpbStatus)) DeviceObject->Flags &= ~DO_VERIFY_VOLUME;
     }
 
+Release:
     /* Signal the device lock and return */
     KeSetEvent(&DeviceObject->DeviceLock, IO_NO_INCREMENT, FALSE);
     return Status;
@@ -764,29 +993,28 @@
     PAGED_CODE();
 
     /* Acquire the FS lock */
-    KeEnterCriticalRegion();
-    ExAcquireResourceExclusiveLite(&FileSystemListLock, TRUE);
+    ExAcquireResourceExclusiveLite(&IopDatabaseResource, TRUE);
 
     /* Check what kind of FS this is */
     if (DeviceObject->DeviceType == FILE_DEVICE_DISK_FILE_SYSTEM)
     {
         /* Use the disk list */
-        FsList = &IopDiskFsListHead;
+        FsList = &IopDiskFileSystemQueueHead;
     }
     else if (DeviceObject->DeviceType == FILE_DEVICE_NETWORK_FILE_SYSTEM)
     {
         /* Use the network device list */
-        FsList = &IopNetworkFsListHead;
+        FsList = &IopNetworkFileSystemQueueHead;
     }
     else if (DeviceObject->DeviceType == FILE_DEVICE_CD_ROM_FILE_SYSTEM)
     {
         /* Use the CD-ROM list */
-        FsList = &IopCdRomFsListHead;
+        FsList = &IopCdRomFileSystemQueueHead;
     }
     else if (DeviceObject->DeviceType == FILE_DEVICE_TAPE_FILE_SYSTEM)
     {
         /* Use the tape list */
-        FsList = &IopTapeFsListHead;
+        FsList = &IopTapeFileSystemQueueHead;
     }
 
     /* Make sure that we have a valid list */
@@ -805,15 +1033,20 @@
         }
     }
 
+    /* Update operations counter */
+    IopFsRegistrationOps++;
+
     /* Clear the initializing flag */
     DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 
-    /* Release the FS Lock */
-    ExReleaseResourceLite(&FileSystemListLock);
-    KeLeaveCriticalRegion();
-
     /* Notify file systems of the addition */
     IopNotifyFileSystemChange(DeviceObject, TRUE);
+
+    /* Release the FS Lock */
+    ExReleaseResourceLite(&IopDatabaseResource);
+
+    /* Ensure driver won't be unloaded */
+    IopInterlockedIncrementUlong(LockQueueIoDatabaseLock,
(PULONG)&DeviceObject->ReferenceCount);
 }
 
 /*
@@ -826,18 +1059,25 @@
     PAGED_CODE();
 
     /* Acquire the FS lock */
-    KeEnterCriticalRegion();
-    ExAcquireResourceExclusiveLite(&FileSystemListLock, TRUE);
-
-    /* Simply remove the entry */
-    RemoveEntryList(&DeviceObject->Queue.ListEntry);
+    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(&FileSystemListLock);
-    KeLeaveCriticalRegion();
+    ExReleaseResourceLite(&IopDatabaseResource);
+
+    /* Decrease reference count to allow unload */
+    IopInterlockedDecrementUlong(LockQueueIoDatabaseLock,
(PULONG)&DeviceObject->ReferenceCount);
 }
 
 /*
@@ -846,25 +1086,60 @@
 NTSTATUS
 NTAPI
 IoRegisterFsRegistrationChange(IN PDRIVER_OBJECT DriverObject,
-                               IN PDRIVER_FS_NOTIFICATION FSDNotificationProc)
+                               IN PDRIVER_FS_NOTIFICATION DriverNotificationRoutine)
 {
     PFS_CHANGE_NOTIFY_ENTRY Entry;
     PAGED_CODE();
+
+    /* Acquire the list lock */
+    ExAcquireResourceExclusiveLite(&IopDatabaseResource, TRUE);
+
+    /* Check if that driver is already registered (successive calls)
+     * See MSDN note: http://msdn.microsoft.com/en-us/library/ff548499%28v=vs.85%29.aspx
+     */
+    if (!IsListEmpty(&IopFsNotifyChangeQueueHead))
+    {
+        Entry = CONTAINING_RECORD(IopFsNotifyChangeQueueHead.Blink,
+                                  FS_CHANGE_NOTIFY_ENTRY,
+                                  FsChangeNotifyList);
+
+        if (Entry->DriverObject == DriverObject &&
+            Entry->FSDNotificationProc == DriverNotificationRoutine)
+        {
+            /* Release the lock */
+            ExReleaseResourceLite(&IopDatabaseResource);
+
+            return STATUS_DEVICE_ALREADY_ATTACHED;
+        }
+    }
 
     /* Allocate a notification entry */
     Entry = ExAllocatePoolWithTag(PagedPool,
                                   sizeof(FS_CHANGE_NOTIFY_ENTRY),
                                   TAG_FS_CHANGE_NOTIFY);
-    if (!Entry) return(STATUS_INSUFFICIENT_RESOURCES);
+    if (!Entry)
+    {
+        /* Release the lock */
+        ExReleaseResourceLite(&IopDatabaseResource);
+
+        return STATUS_INSUFFICIENT_RESOURCES;
+    }
 
     /* Save the driver object and notification routine */
     Entry->DriverObject = DriverObject;
-    Entry->FSDNotificationProc = FSDNotificationProc;
+    Entry->FSDNotificationProc = DriverNotificationRoutine;
 
     /* Insert it into the notification list */
-    KeAcquireGuardedMutex(&FsChangeNotifyListLock);
-    InsertTailList(&FsChangeNotifyListHead, &Entry->FsChangeNotifyList);
-    KeReleaseGuardedMutex(&FsChangeNotifyListLock);
+    InsertTailList(&IopFsNotifyChangeQueueHead, &Entry->FsChangeNotifyList);
+
+    /* Start notifying all already present FS */
+    IopNotifyAlreadyRegisteredFileSystems(&IopNetworkFileSystemQueueHead,
DriverNotificationRoutine, FALSE);
+    IopNotifyAlreadyRegisteredFileSystems(&IopCdRomFileSystemQueueHead,
DriverNotificationRoutine, TRUE);
+    IopNotifyAlreadyRegisteredFileSystems(&IopDiskFileSystemQueueHead,
DriverNotificationRoutine, TRUE);
+    IopNotifyAlreadyRegisteredFileSystems(&IopTapeFileSystemQueueHead,
DriverNotificationRoutine, TRUE);
+
+    /* Release the lock */
+    ExReleaseResourceLite(&IopDatabaseResource);
 
     /* Reference the driver */
     ObReferenceObject(DriverObject);
@@ -884,11 +1159,11 @@
     PAGED_CODE();
 
     /* Acquire the list lock */
-    KeAcquireGuardedMutex(&FsChangeNotifyListLock);
+    ExAcquireResourceExclusiveLite(&IopDatabaseResource, TRUE);
 
     /* Loop the list */
-    NextEntry = FsChangeNotifyListHead.Flink;
-    while (NextEntry != &FsChangeNotifyListHead)
+    NextEntry = IopFsNotifyChangeQueueHead.Flink;
+    while (NextEntry != &IopFsNotifyChangeQueueHead)
     {
         /* Get the entry */
         ChangeEntry = CONTAINING_RECORD(NextEntry,
@@ -910,7 +1185,7 @@
     }
 
     /* Release the lock and dereference the driver */
-    KeReleaseGuardedMutex(&FsChangeNotifyListLock);
+    ExReleaseResourceLite(&IopDatabaseResource);
     ObDereferenceObject(DriverObject);
 }