drivers/filters/mountmgr/notify.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2011 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19  * COPYRIGHT:        See COPYING in the top level directory
  20  * PROJECT:          ReactOS kernel
  21  * FILE:             drivers/filesystem/mountmgr/notify.c
  22  * PURPOSE:          Mount Manager - Notifications handlers
  23  * PROGRAMMER:       Pierre Schweitzer (pierre.schweitzer@reactos.org)
  24  *                   Alex Ionescu (alex.ionescu@reactos.org)
  25  */
  26
  27 #include "mntmgr.h"
  28
  29 #include <ioevent.h>
  30
  31 #define NDEBUG
  32 #include <debug.h>
  33
  34 /*
  35  * @implemented
  36  */
  37 VOID
  38 SendOnlineNotification(IN PUNICODE_STRING SymbolicName)
  39 {
  40     PIRP Irp;
  41     KEVENT Event;
  42     NTSTATUS Status;
  43     PFILE_OBJECT FileObject;
  44     PIO_STACK_LOCATION Stack;
  45     PDEVICE_OBJECT DeviceObject;
  46     IO_STATUS_BLOCK IoStatusBlock;
  47
  48     /* Get device object */
  49     Status = IoGetDeviceObjectPointer(SymbolicName,
  50                                       FILE_READ_ATTRIBUTES,
  51                                       &FileObject,
  52                                       &DeviceObject);
  53     if (!NT_SUCCESS(Status))
  54     {
  55         return;
  56     }
  57
  58     /* And attached device object */
  59     DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
  60
  61     /* And send VOLUME_ONLINE */
  62     KeInitializeEvent(&Event, NotificationEvent, FALSE);
  63     Irp = IoBuildDeviceIoControlRequest(IOCTL_VOLUME_ONLINE,
  64                                         DeviceObject,
  65                                         NULL, 0,
  66                                         NULL, 0,
  67                                         FALSE,
  68                                         &Event,
  69                                         &IoStatusBlock);
  70     if (!Irp)
  71     {
  72         goto Cleanup;
  73     }
  74
  75     Stack = IoGetNextIrpStackLocation(Irp);
  76     Stack->FileObject = FileObject;
  77
  78     Status = IoCallDriver(DeviceObject, Irp);
  79     if (Status == STATUS_PENDING)
  80     {
  81         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
  82     }
  83
  84 Cleanup:
  85     ObDereferenceObject(DeviceObject);
  86     ObDereferenceObject(FileObject);
  87
  88     return;
  89 }
  90
  91 /*
  92  * @implemented
  93  */
  94 VOID
  95 NTAPI
  96 SendOnlineNotificationWorker(IN PVOID Parameter)
  97 {
  98     KIRQL OldIrql;
  99     PLIST_ENTRY Head;
 100     PDEVICE_EXTENSION DeviceExtension;
 101     PONLINE_NOTIFICATION_WORK_ITEM WorkItem;
 102     PONLINE_NOTIFICATION_WORK_ITEM NewWorkItem;
 103
 104     WorkItem = (PONLINE_NOTIFICATION_WORK_ITEM)Parameter;
 105     DeviceExtension = WorkItem->DeviceExtension;
 106
 107     /* First, send the notification */
 108     SendOnlineNotification(&(WorkItem->SymbolicName));
 109
 110     KeAcquireSpinLock(&(DeviceExtension->WorkerLock), &OldIrql);
 111     /* If there are no notifications running any longer, reset event */
 112     if (--DeviceExtension->OnlineNotificationCount == 0)
 113     {
 114         KeSetEvent(&(DeviceExtension->OnlineNotificationEvent), 0, FALSE);
 115     }
 116
 117     /* If there are still notifications in queue */
 118     if (!IsListEmpty(&(DeviceExtension->OnlineNotificationListHead)))
 119     {
 120         /* Queue a new one for execution */
 121         Head = RemoveHeadList(&(DeviceExtension->OnlineNotificationListHead));
 122         NewWorkItem = CONTAINING_RECORD(Head, ONLINE_NOTIFICATION_WORK_ITEM, List);
 123         KeReleaseSpinLock(&(DeviceExtension->WorkerLock), OldIrql);
 124         NewWorkItem->List.Blink = NULL;
 125         NewWorkItem->List.Flink = NULL;
 126         ExQueueWorkItem((PWORK_QUEUE_ITEM)NewWorkItem, DelayedWorkQueue);
 127     }
 128     else
 129     {
 130         /* Mark it's over */
 131         DeviceExtension->OnlineNotificationWorkerActive = 0;
 132         KeReleaseSpinLock(&(DeviceExtension->WorkerLock), OldIrql);
 133     }
 134
 135     FreePool(WorkItem->SymbolicName.Buffer);
 136     FreePool(WorkItem);
 137
 138     return;
 139 }
 140
 141 /*
 142  * @implemented
 143  */
 144 VOID
 145 PostOnlineNotification(IN PDEVICE_EXTENSION DeviceExtension,
 146                        IN PUNICODE_STRING SymbolicName)
 147 {
 148     KIRQL OldIrql;
 149     PONLINE_NOTIFICATION_WORK_ITEM WorkItem;
 150
 151     /* Allocate a notification work item */
 152     WorkItem = AllocatePool(sizeof(ONLINE_NOTIFICATION_WORK_ITEM));
 153     if (!WorkItem)
 154     {
 155         return;
 156     }
 157
 158     WorkItem->List.Flink = NULL;
 159     WorkItem->DeviceExtension = DeviceExtension;
 160     WorkItem->WorkerRoutine = SendOnlineNotificationWorker;
 161     WorkItem->Parameter = WorkItem;
 162     WorkItem->SymbolicName.Length = SymbolicName->Length;
 163     WorkItem->SymbolicName.MaximumLength = SymbolicName->Length + sizeof(WCHAR);
 164     WorkItem->SymbolicName.Buffer = AllocatePool(WorkItem->SymbolicName.MaximumLength);
 165     if (!WorkItem->SymbolicName.Buffer)
 166     {
 167         FreePool(WorkItem);
 168         return;
 169     }
 170
 171     RtlCopyMemory(WorkItem->SymbolicName.Buffer, SymbolicName->Buffer, SymbolicName->Length);
 172     WorkItem->SymbolicName.Buffer[SymbolicName->Length / sizeof(WCHAR)] = UNICODE_NULL;
 173
 174     KeAcquireSpinLock(&(DeviceExtension->WorkerLock), &OldIrql);
 175     DeviceExtension->OnlineNotificationCount++;
 176
 177     /* If no worker are active */
 178     if (DeviceExtension->OnlineNotificationWorkerActive == 0)
 179     {
 180         /* Queue that one for execution */
 181         DeviceExtension->OnlineNotificationWorkerActive = 1;
 182         ExQueueWorkItem((PWORK_QUEUE_ITEM)WorkItem, DelayedWorkQueue);
 183     }
 184     else
 185     {
 186         /* Otherwise, just put it in the queue list */
 187         InsertTailList(&(DeviceExtension->OnlineNotificationListHead), &(WorkItem->List));
 188     }
 189
 190     KeReleaseSpinLock(&(DeviceExtension->WorkerLock), OldIrql);
 191
 192     return;
 193 }
 194
 195 /*
 196  * @implemented
 197  */
 198 VOID
 199 WaitForOnlinesToComplete(IN PDEVICE_EXTENSION DeviceExtension)
 200 {
 201     KIRQL OldIrql;
 202
 203     KeInitializeEvent(&(DeviceExtension->OnlineNotificationEvent), NotificationEvent, FALSE);
 204
 205     KeAcquireSpinLock(&(DeviceExtension->WorkerLock), &OldIrql);
 206
 207     /* Just wait all the worker are done */
 208     if (DeviceExtension->OnlineNotificationCount != 1)
 209     {
 210         DeviceExtension->OnlineNotificationCount--;
 211         KeReleaseSpinLock(&(DeviceExtension->WorkerLock), OldIrql);
 212
 213         KeWaitForSingleObject(&(DeviceExtension->OnlineNotificationEvent),
 214                               Executive,
 215                               KernelMode,
 216                               FALSE,
 217                               NULL);
 218
 219         KeAcquireSpinLock(&(DeviceExtension->WorkerLock), &OldIrql);
 220         DeviceExtension->OnlineNotificationCount++;
 221     }
 222
 223     KeReleaseSpinLock(&(DeviceExtension->WorkerLock), OldIrql);
 224 }
 225
 226 /*
 227  * @implemented
 228  */
 229 NTSTATUS
 230 NTAPI
 231 MountMgrTargetDeviceNotification(IN PVOID NotificationStructure,
 232                                  IN PVOID Context)
 233 {
 234     PDEVICE_EXTENSION DeviceExtension;
 235     PDEVICE_INFORMATION DeviceInformation;
 236     PDEVICE_INTERFACE_CHANGE_NOTIFICATION Notification;
 237
 238     DeviceInformation = Context;
 239     DeviceExtension = DeviceInformation->DeviceExtension;
 240     Notification = NotificationStructure;
 241
 242     /* If it's to signal that removal is complete, then, execute the function */
 243     if (IsEqualGUID(&(Notification->Event), &GUID_TARGET_DEVICE_REMOVE_COMPLETE))
 244     {
 245         MountMgrMountedDeviceRemoval(DeviceExtension, Notification->SymbolicLinkName);
 246     }
 247     /* It it's to signal that a volume has been mounted
 248      * Verify if a database sync is required and execute it
 249      */
 250     else if (IsEqualGUID(&(Notification->Event), &GUID_IO_VOLUME_MOUNT))
 251     {
 252         if (InterlockedCompareExchange(&(DeviceInformation->MountState),
 253                                        FALSE,
 254                                        TRUE) == TRUE)
 255         {
 256             InterlockedDecrement(&(DeviceInformation->MountState));
 257         }
 258         else
 259         {
 260             if (DeviceInformation->NeedsReconcile)
 261             {
 262                 DeviceInformation->NeedsReconcile = FALSE;
 263                 ReconcileThisDatabaseWithMaster(DeviceExtension, DeviceInformation);
 264             }
 265         }
 266     }
 267
 268     return STATUS_SUCCESS;
 269 }
 270
 271 /*
 272  * @implemented
 273  */
 274 VOID
 275 RegisterForTargetDeviceNotification(IN PDEVICE_EXTENSION DeviceExtension,
 276                                     IN PDEVICE_INFORMATION DeviceInformation)
 277 {
 278     NTSTATUS Status;
 279     PFILE_OBJECT FileObject;
 280     PDEVICE_OBJECT DeviceObject;
 281
 282     /* Get device object */
 283     Status = IoGetDeviceObjectPointer(&(DeviceInformation->DeviceName),
 284                                       FILE_READ_ATTRIBUTES,
 285                                       &FileObject,
 286                                       &DeviceObject);
 287     if (!NT_SUCCESS(Status))
 288     {
 289         return;
 290     }
 291
 292     /* And simply register for notifications */
 293     Status = IoRegisterPlugPlayNotification(EventCategoryTargetDeviceChange,
 294                                             0, FileObject,
 295                                             DeviceExtension->DriverObject,
 296                                             MountMgrTargetDeviceNotification,
 297                                             DeviceInformation,
 298                                             &(DeviceInformation->TargetDeviceNotificationEntry));
 299     if (!NT_SUCCESS(Status))
 300     {
 301         DeviceInformation->TargetDeviceNotificationEntry = NULL;
 302     }
 303
 304     ObDereferenceObject(FileObject);
 305
 306     return;
 307 }
 308
 309 /*
 310  * @implemented
 311  */
 312 VOID
 313 MountMgrNotify(IN PDEVICE_EXTENSION DeviceExtension)
 314 {
 315     PIRP Irp;
 316     KIRQL OldIrql;
 317     LIST_ENTRY CopyList;
 318     PLIST_ENTRY NextEntry;
 319
 320     /* Increase the epic number */
 321     DeviceExtension->EpicNumber++;
 322
 323     InitializeListHead(&CopyList);
 324
 325     /* Copy all the pending IRPs for notification */
 326     IoAcquireCancelSpinLock(&OldIrql);
 327     while (!IsListEmpty(&(DeviceExtension->IrpListHead)))
 328     {
 329         NextEntry = RemoveHeadList(&(DeviceExtension->IrpListHead));
 330         Irp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
 331         InsertTailList(&CopyList, &(Irp->Tail.Overlay.ListEntry));
 332     }
 333     IoReleaseCancelSpinLock(OldIrql);
 334
 335     /* Then, notifiy them one by one */
 336     while (!IsListEmpty(&CopyList))
 337     {
 338         NextEntry = RemoveHeadList(&CopyList);
 339         Irp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
 340
 341         *((PULONG)Irp->AssociatedIrp.SystemBuffer) = DeviceExtension->EpicNumber;
 342         Irp->IoStatus.Information = sizeof(DeviceExtension->EpicNumber);
 343
 344         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 345     }
 346 }
 347
 348 /*
 349  * @implemented
 350  */
 351 VOID
 352 MountMgrNotifyNameChange(IN PDEVICE_EXTENSION DeviceExtension,
 353                          IN PUNICODE_STRING DeviceName,
 354                          IN BOOLEAN ValidateVolume)
 355 {
 356     PIRP Irp;
 357     KEVENT Event;
 358     NTSTATUS Status;
 359     PLIST_ENTRY NextEntry;
 360     PFILE_OBJECT FileObject;
 361     PIO_STACK_LOCATION Stack;
 362     PDEVICE_OBJECT DeviceObject;
 363     IO_STATUS_BLOCK IoStatusBlock;
 364     PDEVICE_RELATIONS DeviceRelations;
 365     PDEVICE_INFORMATION DeviceInformation;
 366     TARGET_DEVICE_CUSTOM_NOTIFICATION DeviceNotification;
 367
 368     /* If we have to validate volume */
 369     if (ValidateVolume)
 370     {
 371         /* Then, ensure we can find the device */
 372         NextEntry = DeviceExtension->DeviceListHead.Flink;
 373         while (NextEntry != &(DeviceExtension->DeviceListHead))
 374         {
 375             DeviceInformation = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
 376             if (RtlCompareUnicodeString(DeviceName, &(DeviceInformation->DeviceName), TRUE) == 0)
 377             {
 378                 break;
 379             }
 380         }
 381
 382         if (NextEntry == &(DeviceExtension->DeviceListHead) ||
 383             !DeviceInformation->Volume)
 384         {
 385             return;
 386         }
 387     }
 388
 389     /* Then, get device object */
 390     Status = IoGetDeviceObjectPointer(DeviceName,
 391                                       FILE_READ_ATTRIBUTES,
 392                                       &FileObject,
 393                                       &DeviceObject);
 394     if (!NT_SUCCESS(Status))
 395     {
 396         return;
 397     }
 398
 399     DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
 400
 401     KeInitializeEvent(&Event, NotificationEvent, FALSE);
 402
 403     /* Set up empty IRP (yes, yes!) */
 404     Irp = IoBuildDeviceIoControlRequest(0,
 405                                         DeviceObject,
 406                                         NULL,
 407                                         0,
 408                                         NULL,
 409                                         0,
 410                                         FALSE,
 411                                         &Event,
 412                                         &IoStatusBlock);
 413     if (!Irp)
 414     {
 415         ObDereferenceObject(DeviceObject);
 416         ObDereferenceObject(FileObject);
 417     }
 418
 419     Stack = IoGetNextIrpStackLocation(Irp);
 420
 421     Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 422     Irp->IoStatus.Information = 0;
 423
 424     /* Properly set it, we want to query device relations */
 425     Stack->MajorFunction = IRP_MJ_PNP;
 426     Stack->MinorFunction = IRP_MN_QUERY_DEVICE_RELATIONS;
 427     Stack->Parameters.QueryDeviceRelations.Type = TargetDeviceRelation;
 428     Stack->FileObject = FileObject;
 429
 430     /* And call driver */
 431     Status = IoCallDriver(DeviceObject, Irp);
 432     if (Status == STATUS_PENDING)
 433     {
 434         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
 435         Status = IoStatusBlock.Status;
 436     }
 437
 438     ObDereferenceObject(DeviceObject);
 439     ObDereferenceObject(FileObject);
 440
 441     if (!NT_SUCCESS(Status))
 442     {
 443         return;
 444     }
 445
 446     /* Validate device return */
 447     DeviceRelations = (PDEVICE_RELATIONS)IoStatusBlock.Information;
 448     if (DeviceRelations->Count < 1)
 449     {
 450         ExFreePool(DeviceRelations);
 451         return;
 452     }
 453
 454     DeviceObject = DeviceRelations->Objects[0];
 455     ExFreePool(DeviceRelations);
 456
 457     /* Set up real notification */
 458     DeviceNotification.Version = 1;
 459     DeviceNotification.Size = sizeof(TARGET_DEVICE_CUSTOM_NOTIFICATION);
 460     DeviceNotification.Event = GUID_IO_VOLUME_NAME_CHANGE;
 461     DeviceNotification.FileObject = NULL;
 462     DeviceNotification.NameBufferOffset = -1;
 463
 464     /* And report */
 465     IoReportTargetDeviceChangeAsynchronous(DeviceObject,
 466                                            &DeviceNotification,
 467                                            NULL, NULL);
 468
 469     ObDereferenceObject(DeviceObject);
 470
 471     return;
 472 }
 473
 474 /*
 475  * @implemented
 476  */
 477 VOID
 478 RemoveWorkItem(IN PUNIQUE_ID_WORK_ITEM WorkItem)
 479 {
 480     PDEVICE_EXTENSION DeviceExtension = WorkItem->DeviceExtension;
 481
 482     KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
 483
 484     /* If even if being worked, it's too late */
 485     if (WorkItem->Event)
 486     {
 487         KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
 488         KeSetEvent(WorkItem->Event, 0, FALSE);
 489     }
 490     else
 491     {
 492         /* Otherwise, remove it from the list, and delete it */
 493         RemoveEntryList(&(WorkItem->UniqueIdWorkerItemListEntry));
 494         KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
 495         IoFreeIrp(WorkItem->Irp);
 496         FreePool(WorkItem->DeviceName.Buffer);
 497         FreePool(WorkItem->IrpBuffer);
 498         FreePool(WorkItem);
 499     }
 500 }
 501
 502 /*
 503  * @implemented
 504  */
 505 VOID
 506 NTAPI
 507 UniqueIdChangeNotifyWorker(IN PDEVICE_OBJECT DeviceObject,
 508                            IN PVOID Context)
 509 {
 510     PUNIQUE_ID_WORK_ITEM WorkItem = Context;
 511     PMOUNTDEV_UNIQUE_ID OldUniqueId, NewUniqueId;
 512     PMOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY_OUTPUT UniqueIdChange;
 513
 514     UNREFERENCED_PARAMETER(DeviceObject);
 515
 516     /* Validate worker */
 517     if (!NT_SUCCESS(WorkItem->Irp->IoStatus.Status))
 518     {
 519         RemoveWorkItem(WorkItem);
 520         return;
 521     }
 522
 523     UniqueIdChange = WorkItem->Irp->AssociatedIrp.SystemBuffer;
 524     /* Get the old unique ID */
 525     OldUniqueId = AllocatePool(UniqueIdChange->OldUniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
 526     if (!OldUniqueId)
 527     {
 528         RemoveWorkItem(WorkItem);
 529         return;
 530     }
 531
 532     OldUniqueId->UniqueIdLength = UniqueIdChange->OldUniqueIdLength;
 533     RtlCopyMemory(OldUniqueId->UniqueId,
 534                   (PVOID)((ULONG_PTR)UniqueIdChange + UniqueIdChange->OldUniqueIdOffset),
 535                   UniqueIdChange->OldUniqueIdLength);
 536
 537     /* Get the new unique ID */
 538     NewUniqueId = AllocatePool(UniqueIdChange->NewUniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
 539     if (!NewUniqueId)
 540     {
 541         FreePool(OldUniqueId);
 542         RemoveWorkItem(WorkItem);
 543         return;
 544     }
 545
 546     NewUniqueId->UniqueIdLength = UniqueIdChange->NewUniqueIdLength;
 547     RtlCopyMemory(NewUniqueId->UniqueId,
 548                   (PVOID)((ULONG_PTR)UniqueIdChange + UniqueIdChange->NewUniqueIdOffset),
 549                   UniqueIdChange->NewUniqueIdLength);
 550
 551     /* Call the real worker */
 552     MountMgrUniqueIdChangeRoutine(WorkItem->DeviceExtension, OldUniqueId, NewUniqueId);
 553     IssueUniqueIdChangeNotifyWorker(WorkItem, NewUniqueId);
 554
 555     FreePool(NewUniqueId);
 556     FreePool(OldUniqueId);
 557
 558     return;
 559 }
 560
 561 /*
 562  * @implemented
 563  */
 564 NTSTATUS
 565 NTAPI
 566 UniqueIdChangeNotifyCompletion(IN PDEVICE_OBJECT DeviceObject,
 567                                IN PIRP Irp,
 568                                IN PVOID Context)
 569 {
 570     PUNIQUE_ID_WORK_ITEM WorkItem = Context;
 571
 572     UNREFERENCED_PARAMETER(DeviceObject);
 573     UNREFERENCED_PARAMETER(Irp);
 574
 575     /* Simply queue the work item */
 576     IoQueueWorkItem(WorkItem->WorkItem,
 577                     UniqueIdChangeNotifyWorker,
 578                     DelayedWorkQueue,
 579                     WorkItem);
 580
 581     return STATUS_MORE_PROCESSING_REQUIRED;
 582 }
 583
 584 /*
 585  * @implemented
 586  */
 587 VOID
 588 IssueUniqueIdChangeNotifyWorker(IN PUNIQUE_ID_WORK_ITEM WorkItem,
 589                                 IN PMOUNTDEV_UNIQUE_ID UniqueId)
 590 {
 591     PIRP Irp;
 592     NTSTATUS Status;
 593     PFILE_OBJECT FileObject;
 594     PIO_STACK_LOCATION Stack;
 595     PDEVICE_OBJECT DeviceObject;
 596
 597     /* Get the device object */
 598     Status = IoGetDeviceObjectPointer(&(WorkItem->DeviceName),
 599                                       FILE_READ_ATTRIBUTES,
 600                                       &FileObject,
 601                                       &DeviceObject);
 602     if (!NT_SUCCESS(Status))
 603     {
 604         RemoveWorkItem(WorkItem);
 605         return;
 606     }
 607
 608     /* And then, the attached device */
 609     DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
 610
 611     /* Initialize the IRP */
 612     Irp = WorkItem->Irp;
 613     IoInitializeIrp(Irp, IoSizeOfIrp(WorkItem->StackSize), (CCHAR)WorkItem->StackSize);
 614
 615     if (InterlockedExchange((PLONG)&(WorkItem->Event), 0) != 0)
 616     {
 617         ObDereferenceObject(FileObject);
 618         ObDereferenceObject(DeviceObject);
 619         RemoveWorkItem(WorkItem);
 620         return;
 621     }
 622
 623     Irp->AssociatedIrp.SystemBuffer = WorkItem->IrpBuffer;
 624     Irp->Tail.Overlay.Thread = PsGetCurrentThread();
 625     RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, UniqueId, UniqueId->UniqueIdLength + sizeof(USHORT));
 626
 627     Stack = IoGetNextIrpStackLocation(Irp);
 628
 629     Stack->Parameters.DeviceIoControl.InputBufferLength = UniqueId->UniqueIdLength + sizeof(USHORT);
 630     Stack->Parameters.DeviceIoControl.OutputBufferLength = WorkItem->IrpBufferLength;
 631     Stack->Parameters.DeviceIoControl.Type3InputBuffer = 0;
 632     Stack->Parameters.DeviceIoControl.IoControlCode = IOCTL_MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY;
 633     Stack->MajorFunction = IRP_MJ_DEVICE_CONTROL;
 634
 635     Status = IoSetCompletionRoutineEx(WorkItem->DeviceExtension->DeviceObject,
 636                                       Irp,
 637                                       UniqueIdChangeNotifyCompletion,
 638                                       WorkItem,
 639                                       TRUE, TRUE, TRUE);
 640     if (!NT_SUCCESS(Status))
 641     {
 642         ObDereferenceObject(FileObject);
 643         ObDereferenceObject(DeviceObject);
 644         RemoveWorkItem(WorkItem);
 645         return;
 646     }
 647
 648     /* Call the driver */
 649     IoCallDriver(DeviceObject, Irp);
 650     ObDereferenceObject(FileObject);
 651     ObDereferenceObject(DeviceObject);
 652 }
 653
 654 /*
 655  * @implemented
 656  */
 657 VOID
 658 IssueUniqueIdChangeNotify(IN PDEVICE_EXTENSION DeviceExtension,
 659                           IN PUNICODE_STRING DeviceName,
 660                           IN PMOUNTDEV_UNIQUE_ID UniqueId)
 661 {
 662     NTSTATUS Status;
 663     PVOID IrpBuffer = NULL;
 664     PFILE_OBJECT FileObject;
 665     PDEVICE_OBJECT DeviceObject;
 666     PUNIQUE_ID_WORK_ITEM WorkItem = NULL;
 667
 668     /* Get the associated device object */
 669     Status = IoGetDeviceObjectPointer(DeviceName,
 670                                       FILE_READ_ATTRIBUTES,
 671                                       &FileObject,
 672                                       &DeviceObject);
 673     if (!NT_SUCCESS(Status))
 674     {
 675         return;
 676     }
 677
 678     /* And then, get attached device */
 679     DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
 680
 681     ObDereferenceObject(FileObject);
 682
 683     /* Allocate a work item */
 684     WorkItem = AllocatePool(sizeof(UNIQUE_ID_WORK_ITEM));
 685     if (!WorkItem)
 686     {
 687         ObDereferenceObject(DeviceObject);
 688         return;
 689     }
 690
 691     WorkItem->Event = NULL;
 692     WorkItem->WorkItem = IoAllocateWorkItem(DeviceExtension->DeviceObject);
 693     if (!WorkItem->WorkItem)
 694     {
 695         ObDereferenceObject(DeviceObject);
 696         goto Cleanup;
 697     }
 698
 699     WorkItem->DeviceExtension = DeviceExtension;
 700     WorkItem->StackSize = DeviceObject->StackSize;
 701     /* Already provide the IRP */
 702     WorkItem->Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
 703
 704     ObDereferenceObject(DeviceObject);
 705
 706     if (!WorkItem->Irp)
 707     {
 708         goto Cleanup;
 709     }
 710
 711     /* Ensure it has enough space */
 712     IrpBuffer = AllocatePool(sizeof(MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY_OUTPUT) + 1024);
 713     if (!IrpBuffer)
 714     {
 715         goto Cleanup;
 716     }
 717
 718     WorkItem->DeviceName.Length = DeviceName->Length;
 719     WorkItem->DeviceName.MaximumLength = DeviceName->Length + sizeof(WCHAR);
 720     WorkItem->DeviceName.Buffer = AllocatePool(WorkItem->DeviceName.MaximumLength);
 721     if (!WorkItem->DeviceName.Buffer)
 722     {
 723         goto Cleanup;
 724     }
 725
 726     RtlCopyMemory(WorkItem->DeviceName.Buffer, DeviceName->Buffer, DeviceName->Length);
 727     WorkItem->DeviceName.Buffer[DeviceName->Length / sizeof(WCHAR)] = UNICODE_NULL;
 728
 729     WorkItem->IrpBuffer = IrpBuffer;
 730     WorkItem->IrpBufferLength = sizeof(MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY_OUTPUT) + 1024;
 731
 732     /* Add the worker in the list */
 733     KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
 734     InsertHeadList(&(DeviceExtension->UniqueIdWorkerItemListHead), &(WorkItem->UniqueIdWorkerItemListEntry));
 735     KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
 736
 737     /* And call the worker */
 738     IssueUniqueIdChangeNotifyWorker(WorkItem, UniqueId);
 739
 740     return;
 741
 742 Cleanup:
 743     if (IrpBuffer)
 744     {
 745         FreePool(IrpBuffer);
 746     }
 747
 748     if (WorkItem->Irp)
 749     {
 750         IoFreeIrp(WorkItem->Irp);
 751     }
 752
 753     if (WorkItem->WorkItem)
 754     {
 755         IoFreeWorkItem(WorkItem->WorkItem);
 756     }
 757
 758     if (WorkItem)
 759     {
 760         FreePool(WorkItem);
 761     }
 762 }