Synchronize with trunk's revision r57652.
[reactos.git] / 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 /* INCLUDES *****************************************************************/
28
29 #include "mntmgr.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 /* Validate worker */
515 if (!NT_SUCCESS(WorkItem->Irp->IoStatus.Status))
516 {
517 RemoveWorkItem(WorkItem);
518 return;
519 }
520
521 UniqueIdChange = WorkItem->Irp->AssociatedIrp.SystemBuffer;
522 /* Get the old unique ID */
523 OldUniqueId = AllocatePool(UniqueIdChange->OldUniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
524 if (!OldUniqueId)
525 {
526 RemoveWorkItem(WorkItem);
527 return;
528 }
529
530 OldUniqueId->UniqueIdLength = UniqueIdChange->OldUniqueIdLength;
531 RtlCopyMemory(OldUniqueId->UniqueId,
532 (PVOID)((ULONG_PTR)UniqueIdChange + UniqueIdChange->OldUniqueIdOffset),
533 UniqueIdChange->OldUniqueIdLength);
534
535 /* Get the new unique ID */
536 NewUniqueId = AllocatePool(UniqueIdChange->NewUniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
537 if (!NewUniqueId)
538 {
539 FreePool(OldUniqueId);
540 RemoveWorkItem(WorkItem);
541 return;
542 }
543
544 NewUniqueId->UniqueIdLength = UniqueIdChange->NewUniqueIdLength;
545 RtlCopyMemory(NewUniqueId->UniqueId,
546 (PVOID)((ULONG_PTR)UniqueIdChange + UniqueIdChange->NewUniqueIdOffset),
547 UniqueIdChange->NewUniqueIdLength);
548
549 /* Call the real worker */
550 MountMgrUniqueIdChangeRoutine(WorkItem->DeviceExtension, OldUniqueId, NewUniqueId);
551 IssueUniqueIdChangeNotifyWorker(WorkItem, NewUniqueId);
552
553 FreePool(NewUniqueId);
554 FreePool(OldUniqueId);
555
556 return;
557 }
558
559 /*
560 * @implemented
561 */
562 NTSTATUS
563 NTAPI
564 UniqueIdChangeNotifyCompletion(IN PDEVICE_OBJECT DeviceObject,
565 IN PIRP Irp,
566 IN PVOID Context)
567 {
568 PUNIQUE_ID_WORK_ITEM WorkItem = Context;
569
570 /* Simply queue the work item */
571 IoQueueWorkItem(WorkItem->WorkItem,
572 UniqueIdChangeNotifyWorker,
573 DelayedWorkQueue,
574 WorkItem);
575
576 return STATUS_MORE_PROCESSING_REQUIRED;
577 }
578
579 /*
580 * @implemented
581 */
582 VOID
583 IssueUniqueIdChangeNotifyWorker(IN PUNIQUE_ID_WORK_ITEM WorkItem,
584 IN PMOUNTDEV_UNIQUE_ID UniqueId)
585 {
586 PIRP Irp;
587 NTSTATUS Status;
588 PFILE_OBJECT FileObject;
589 PIO_STACK_LOCATION Stack;
590 PDEVICE_OBJECT DeviceObject;
591
592 /* Get the device object */
593 Status = IoGetDeviceObjectPointer(&(WorkItem->DeviceName),
594 FILE_READ_ATTRIBUTES,
595 &FileObject,
596 &DeviceObject);
597 if (!NT_SUCCESS(Status))
598 {
599 RemoveWorkItem(WorkItem);
600 return;
601 }
602
603 /* And then, the attached device */
604 DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
605
606 /* Initialize the IRP */
607 Irp = WorkItem->Irp;
608 IoInitializeIrp(Irp, IoSizeOfIrp(WorkItem->StackSize), (CCHAR)WorkItem->StackSize);
609
610 if (InterlockedExchange((PLONG)&(WorkItem->Event), 0) != 0)
611 {
612 ObDereferenceObject(FileObject);
613 ObDereferenceObject(DeviceObject);
614 RemoveWorkItem(WorkItem);
615 return;
616 }
617
618 Irp->AssociatedIrp.SystemBuffer = WorkItem->IrpBuffer;
619 Irp->Tail.Overlay.Thread = PsGetCurrentThread();
620 RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, UniqueId, UniqueId->UniqueIdLength + sizeof(USHORT));
621
622 Stack = IoGetNextIrpStackLocation(Irp);
623
624 Stack->Parameters.DeviceIoControl.InputBufferLength = UniqueId->UniqueIdLength + sizeof(USHORT);
625 Stack->Parameters.DeviceIoControl.OutputBufferLength = WorkItem->IrpBufferLength;
626 Stack->Parameters.DeviceIoControl.Type3InputBuffer = 0;
627 Stack->Parameters.DeviceIoControl.IoControlCode = IOCTL_MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY;
628 Stack->MajorFunction = IRP_MJ_DEVICE_CONTROL;
629
630 Status = IoSetCompletionRoutineEx(WorkItem->DeviceExtension->DeviceObject,
631 Irp,
632 UniqueIdChangeNotifyCompletion,
633 WorkItem,
634 TRUE, TRUE, TRUE);
635 if (!NT_SUCCESS(Status))
636 {
637 ObDereferenceObject(FileObject);
638 ObDereferenceObject(DeviceObject);
639 RemoveWorkItem(WorkItem);
640 return;
641 }
642
643 /* Call the driver */
644 IoCallDriver(DeviceObject, Irp);
645 ObDereferenceObject(FileObject);
646 ObDereferenceObject(DeviceObject);
647 }
648
649 /*
650 * @implemented
651 */
652 VOID
653 IssueUniqueIdChangeNotify(IN PDEVICE_EXTENSION DeviceExtension,
654 IN PUNICODE_STRING DeviceName,
655 IN PMOUNTDEV_UNIQUE_ID UniqueId)
656 {
657 NTSTATUS Status;
658 PVOID IrpBuffer = NULL;
659 PFILE_OBJECT FileObject;
660 PDEVICE_OBJECT DeviceObject;
661 PUNIQUE_ID_WORK_ITEM WorkItem = NULL;
662
663 /* Get the associated device object */
664 Status = IoGetDeviceObjectPointer(DeviceName,
665 FILE_READ_ATTRIBUTES,
666 &FileObject,
667 &DeviceObject);
668 if (!NT_SUCCESS(Status))
669 {
670 return;
671 }
672
673 /* And then, get attached device */
674 DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
675
676 ObDereferenceObject(FileObject);
677
678 /* Allocate a work item */
679 WorkItem = AllocatePool(sizeof(UNIQUE_ID_WORK_ITEM));
680 if (!WorkItem)
681 {
682 ObDereferenceObject(DeviceObject);
683 return;
684 }
685
686 WorkItem->Event = NULL;
687 WorkItem->WorkItem = IoAllocateWorkItem(DeviceExtension->DeviceObject);
688 if (!WorkItem->WorkItem)
689 {
690 ObDereferenceObject(DeviceObject);
691 goto Cleanup;
692 }
693
694 WorkItem->DeviceExtension = DeviceExtension;
695 WorkItem->StackSize = DeviceObject->StackSize;
696 /* Already provide the IRP */
697 WorkItem->Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
698
699 ObDereferenceObject(DeviceObject);
700
701 if (!WorkItem->Irp)
702 {
703 goto Cleanup;
704 }
705
706 /* Ensure it has enough space */
707 IrpBuffer = AllocatePool(sizeof(MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY_OUTPUT) + 1024);
708 if (!IrpBuffer)
709 {
710 goto Cleanup;
711 }
712
713 WorkItem->DeviceName.Length = DeviceName->Length;
714 WorkItem->DeviceName.MaximumLength = DeviceName->Length + sizeof(WCHAR);
715 WorkItem->DeviceName.Buffer = AllocatePool(WorkItem->DeviceName.MaximumLength);
716 if (!WorkItem->DeviceName.Buffer)
717 {
718 goto Cleanup;
719 }
720
721 RtlCopyMemory(WorkItem->DeviceName.Buffer, DeviceName->Buffer, DeviceName->Length);
722 WorkItem->DeviceName.Buffer[DeviceName->Length / sizeof(WCHAR)] = UNICODE_NULL;
723
724 WorkItem->IrpBuffer = IrpBuffer;
725 WorkItem->IrpBufferLength = sizeof(MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY_OUTPUT) + 1024;
726
727 /* Add the worker in the list */
728 KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
729 InsertHeadList(&(DeviceExtension->UniqueIdWorkerItemListHead), &(WorkItem->UniqueIdWorkerItemListEntry));
730 KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
731
732 /* And call the worker */
733 IssueUniqueIdChangeNotifyWorker(WorkItem, UniqueId);
734
735 return;
736
737 Cleanup:
738 if (IrpBuffer)
739 {
740 FreePool(IrpBuffer);
741 }
742
743 if (WorkItem->Irp)
744 {
745 IoFreeIrp(WorkItem->Irp);
746 }
747
748 if (WorkItem->WorkItem)
749 {
750 IoFreeWorkItem(WorkItem->WorkItem);
751 }
752
753 if (WorkItem)
754 {
755 FreePool(WorkItem);
756 }
757 }