4ee8096c7e6ec40d63e002b43b19f50d1ac4b824
[reactos.git] / reactos / drivers / filters / mountmgr / device.c
1 /*
2 * ReactOS kernel
3 * Copyright (C) 2011-2012 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/device.c
22 * PURPOSE: Mount Manager - Device Control
23 * PROGRAMMER: Pierre Schweitzer (pierre.schweitzer@reactos.org)
24 */
25
26 #include "mntmgr.h"
27
28 #define MAX_DEVICES 0x3E8 /* Matches 1000 devices */
29
30 #define NDEBUG
31 #include <debug.h>
32
33 /*
34 * @implemented
35 */
36 NTSTATUS
37 MountMgrChangeNotify(IN PDEVICE_EXTENSION DeviceExtension,
38 IN PIRP Irp)
39 {
40 KIRQL OldIrql;
41 NTSTATUS Status;
42 PIO_STACK_LOCATION Stack;
43 PMOUNTMGR_CHANGE_NOTIFY_INFO ChangeNotify;
44
45 /* Get the I/O buffer */
46 Stack = IoGetCurrentIrpStackLocation(Irp);
47 ChangeNotify = (PMOUNTMGR_CHANGE_NOTIFY_INFO)Irp->AssociatedIrp.SystemBuffer;
48
49 /* Validate it */
50 if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(MOUNTMGR_CHANGE_NOTIFY_INFO) ||
51 Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_CHANGE_NOTIFY_INFO))
52 {
53 return STATUS_INVALID_PARAMETER;
54 }
55
56 /* If epic number doesn't match, just return now one */
57 if (DeviceExtension->EpicNumber != ChangeNotify->EpicNumber)
58 {
59 ChangeNotify->EpicNumber = DeviceExtension->EpicNumber;
60 Irp->IoStatus.Information = 0;
61 return STATUS_SUCCESS;
62 }
63
64 /* If IRP is to be canceled, forget about that */
65 IoAcquireCancelSpinLock(&OldIrql);
66 if (Irp->Cancel)
67 {
68 Status = STATUS_CANCELLED;
69 }
70 /* Otherwise queue the IRP to be notified with the next epic number change */
71 else
72 {
73 InsertTailList(&(DeviceExtension->IrpListHead), &(Irp->Tail.Overlay.ListEntry));
74 IoMarkIrpPending(Irp);
75 IoSetCancelRoutine(Irp, MountMgrCancel);
76 Status = STATUS_PENDING;
77 }
78 IoReleaseCancelSpinLock(OldIrql);
79
80 return Status;
81 }
82
83 /*
84 * @implemented
85 */
86 NTSTATUS
87 MountmgrWriteNoAutoMount(IN PDEVICE_EXTENSION DeviceExtension)
88 {
89 ULONG Value = DeviceExtension->NoAutoMount;
90
91 return RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
92 DeviceExtension->RegistryPath.Buffer,
93 L"NoAutoMount",
94 REG_DWORD,
95 &Value,
96 sizeof(Value));
97
98 }
99
100 /*
101 * @implemented
102 */
103 NTSTATUS
104 MountMgrSetAutoMount(IN PDEVICE_EXTENSION DeviceExtension,
105 IN PIRP Irp)
106 {
107 PIO_STACK_LOCATION Stack;
108 PMOUNTMGR_SET_AUTO_MOUNT SetState;
109
110 Stack = IoGetCurrentIrpStackLocation(Irp);
111
112 if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_SET_AUTO_MOUNT))
113 {
114 Irp->IoStatus.Information = 0;
115 return STATUS_INVALID_PARAMETER;
116 }
117
118 /* Only change if there's a real difference */
119 SetState = (PMOUNTMGR_SET_AUTO_MOUNT)Irp->AssociatedIrp.SystemBuffer;
120 if (SetState->NewState == !DeviceExtension->NoAutoMount)
121 {
122 Irp->IoStatus.Information = 0;
123 return STATUS_SUCCESS;
124 }
125
126 /* Set new state; ! on purpose */
127 DeviceExtension->NoAutoMount = !SetState->NewState;
128 Irp->IoStatus.Information = 0;
129 return MountmgrWriteNoAutoMount(DeviceExtension);
130 }
131
132 /*
133 * @implemented
134 */
135 NTSTATUS
136 MountMgrQueryAutoMount(IN PDEVICE_EXTENSION DeviceExtension,
137 IN PIRP Irp)
138 {
139 PIO_STACK_LOCATION Stack;
140 PMOUNTMGR_QUERY_AUTO_MOUNT QueryState;
141
142 Stack = IoGetCurrentIrpStackLocation(Irp);
143
144 if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(MOUNTMGR_QUERY_AUTO_MOUNT))
145 {
146 Irp->IoStatus.Information = 0;
147 return STATUS_INVALID_PARAMETER;
148 }
149
150 QueryState = (PMOUNTMGR_QUERY_AUTO_MOUNT)Irp->AssociatedIrp.SystemBuffer;
151 QueryState->CurrentState = !DeviceExtension->NoAutoMount;
152 Irp->IoStatus.Information = sizeof(MOUNTMGR_QUERY_AUTO_MOUNT);
153
154 return STATUS_SUCCESS;
155 }
156
157 /*
158 * @implemented
159 */
160 NTSTATUS
161 NTAPI
162 ScrubRegistryRoutine(IN PWSTR ValueName,
163 IN ULONG ValueType,
164 IN PVOID ValueData,
165 IN ULONG ValueLength,
166 IN PVOID Context,
167 IN PVOID EntryContext)
168 {
169 NTSTATUS Status;
170 PLIST_ENTRY NextEntry;
171 PDEVICE_INFORMATION DeviceInfo;
172 PBOOLEAN Continue = EntryContext;
173 PDEVICE_EXTENSION DeviceExtension = Context;
174
175 if (ValueType != REG_BINARY)
176 {
177 return STATUS_SUCCESS;
178 }
179
180 /* Delete values for devices that don't have the matching unique ID */
181 if (!IsListEmpty(&(DeviceExtension->DeviceListHead)))
182 {
183 for (NextEntry = DeviceExtension->DeviceListHead.Flink;
184 NextEntry != &(DeviceExtension->DeviceListHead);
185 NextEntry = NextEntry->Flink)
186 {
187 DeviceInfo = CONTAINING_RECORD(NextEntry,
188 DEVICE_INFORMATION,
189 DeviceListEntry);
190
191 if (!DeviceInfo->UniqueId || DeviceInfo->UniqueId->UniqueIdLength != ValueLength)
192 {
193 continue;
194 }
195
196 if (RtlCompareMemory(DeviceInfo->UniqueId->UniqueId, ValueData, ValueLength) == ValueLength)
197 {
198 return STATUS_SUCCESS;
199 }
200 }
201 }
202
203 /* Wrong unique ID, scrub it */
204 Status = RtlDeleteRegistryValue(RTL_REGISTRY_ABSOLUTE,
205 DatabasePath,
206 ValueName);
207 if (!NT_SUCCESS(Status))
208 {
209 *Continue = TRUE;
210 return STATUS_UNSUCCESSFUL;
211 }
212
213 *Continue = FALSE;
214 return Status;
215 }
216
217 /*
218 * @implemented
219 */
220 NTSTATUS
221 MountMgrScrubRegistry(IN PDEVICE_EXTENSION DeviceExtension)
222 {
223 NTSTATUS Status;
224 BOOLEAN Continue;
225 RTL_QUERY_REGISTRY_TABLE QueryTable[2];
226
227 do
228 {
229 RtlZeroMemory(QueryTable, sizeof(QueryTable));
230 QueryTable[0].QueryRoutine = ScrubRegistryRoutine;
231 QueryTable[0].EntryContext = &Continue;
232 Continue = FALSE;
233
234 Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
235 DatabasePath,
236 QueryTable,
237 DeviceExtension,
238 NULL);
239 }
240 while (Continue);
241
242 return Status;
243 }
244
245 /*
246 * @implemented
247 */
248 NTSTATUS
249 MountMgrCreatePoint(IN PDEVICE_EXTENSION DeviceExtension,
250 IN PIRP Irp)
251 {
252 ULONG MaxLength;
253 PIO_STACK_LOCATION Stack;
254 PMOUNTMGR_CREATE_POINT_INPUT Point;
255 UNICODE_STRING DeviceName, SymbolicName;
256
257 Stack = IoGetCurrentIrpStackLocation(Irp);
258
259 if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_CREATE_POINT_INPUT))
260 {
261 return STATUS_INVALID_PARAMETER;
262 }
263
264 Point = (PMOUNTMGR_CREATE_POINT_INPUT)Irp->AssociatedIrp.SystemBuffer;
265
266 MaxLength = MAX((Point->DeviceNameOffset + Point->DeviceNameLength),
267 (Point->SymbolicLinkNameLength + Point->SymbolicLinkNameOffset));
268 if (MaxLength >= Stack->Parameters.DeviceIoControl.InputBufferLength)
269 {
270 return STATUS_INVALID_PARAMETER;
271 }
272
273 /* Get all the strings and call the worker */
274 SymbolicName.Length = Point->SymbolicLinkNameLength;
275 SymbolicName.MaximumLength = Point->SymbolicLinkNameLength;
276 DeviceName.Length = Point->DeviceNameLength;
277 DeviceName.MaximumLength = Point->DeviceNameLength;
278 SymbolicName.Buffer = (PVOID)((ULONG_PTR)Point + Point->SymbolicLinkNameOffset);
279 DeviceName.Buffer = (PVOID)((ULONG_PTR)Point + Point->DeviceNameOffset);
280
281 return MountMgrCreatePointWorker(DeviceExtension, &SymbolicName, &DeviceName);
282 }
283
284 /*
285 * @implemented
286 */
287 NTSTATUS
288 MountMgrCheckUnprocessedVolumes(IN PDEVICE_EXTENSION DeviceExtension,
289 IN PIRP Irp)
290 {
291 PLIST_ENTRY NextEntry;
292 PDEVICE_INFORMATION DeviceInformation;
293 NTSTATUS ArrivalStatus, Status = STATUS_SUCCESS;
294
295 UNREFERENCED_PARAMETER(Irp);
296
297 /* No offline volumes, nothing more to do */
298 if (IsListEmpty(&(DeviceExtension->OfflineDeviceListHead)))
299 {
300 KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
301 return STATUS_SUCCESS;
302 }
303
304 KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
305
306 /* Reactivate all the offline volumes */
307 while (!IsListEmpty(&(DeviceExtension->OfflineDeviceListHead)))
308 {
309 NextEntry = RemoveHeadList(&(DeviceExtension->OfflineDeviceListHead));
310 DeviceInformation = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
311
312 ArrivalStatus = MountMgrMountedDeviceArrival(DeviceExtension,
313 &(DeviceInformation->SymbolicName),
314 DeviceInformation->Volume);
315 /* Then, remove them dead information */
316 MountMgrFreeDeadDeviceInfo(DeviceInformation);
317
318 if (NT_SUCCESS(Status))
319 {
320 Status = ArrivalStatus;
321 }
322 }
323
324 return Status;
325 }
326
327 /*
328 * @implemented
329 */
330 BOOLEAN
331 IsFtVolume(IN PUNICODE_STRING SymbolicName)
332 {
333 PIRP Irp;
334 KEVENT Event;
335 NTSTATUS Status;
336 PFILE_OBJECT FileObject;
337 IO_STATUS_BLOCK IoStatusBlock;
338 PARTITION_INFORMATION PartitionInfo;
339 PDEVICE_OBJECT DeviceObject, FileDeviceObject;
340
341 /* Get device object */
342 Status = IoGetDeviceObjectPointer(SymbolicName,
343 FILE_READ_ATTRIBUTES,
344 &FileObject,
345 &DeviceObject);
346 if (!NT_SUCCESS(Status))
347 {
348 return FALSE;
349 }
350
351 /* Get attached device */
352 FileDeviceObject = FileObject->DeviceObject;
353 DeviceObject = IoGetAttachedDeviceReference(FileDeviceObject);
354
355 /* FT volume can't be removable */
356 if (FileDeviceObject->Characteristics & FILE_REMOVABLE_MEDIA)
357 {
358 ObDereferenceObject(DeviceObject);
359 ObDereferenceObject(FileObject);
360 return FALSE;
361 }
362
363 ObDereferenceObject(FileObject);
364
365 /* Get partition information */
366 KeInitializeEvent(&Event, NotificationEvent, FALSE);
367 Irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_PARTITION_INFO,
368 DeviceObject,
369 NULL,
370 0,
371 &PartitionInfo,
372 sizeof(PartitionInfo),
373 FALSE,
374 &Event,
375 &IoStatusBlock);
376 if (!Irp)
377 {
378 ObDereferenceObject(DeviceObject);
379 return FALSE;
380 }
381
382 Status = IoCallDriver(DeviceObject, Irp);
383 if (Status == STATUS_PENDING)
384 {
385 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
386 Status = IoStatusBlock.Status;
387 }
388
389 ObDereferenceObject(DeviceObject);
390 if (!NT_SUCCESS(Status))
391 {
392 return FALSE;
393 }
394
395 /* Check if this is a FT volume */
396 return IsRecognizedPartition(PartitionInfo.PartitionType);
397 }
398
399 /*
400 * @implemented
401 */
402 VOID
403 ProcessSuggestedDriveLetters(IN PDEVICE_EXTENSION DeviceExtension)
404 {
405 WCHAR NameBuffer[DRIVE_LETTER_LENGTH / sizeof(WCHAR)];
406 PLIST_ENTRY NextEntry;
407 UNICODE_STRING SymbolicName;
408 PDEVICE_INFORMATION DeviceInformation;
409
410 /* No devices? Nothing to do! */
411 if (IsListEmpty(&(DeviceExtension->DeviceListHead)))
412 {
413 return;
414 }
415
416 /* For all the devices */
417 for (NextEntry = DeviceExtension->DeviceListHead.Flink;
418 NextEntry != &(DeviceExtension->DeviceListHead);
419 NextEntry = NextEntry->Flink)
420 {
421 DeviceInformation = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
422
423 /* If no drive letter */
424 if (DeviceInformation->SuggestedDriveLetter == (UCHAR)-1)
425 {
426 /* Ensure it has no entry yet */
427 if (!HasDriveLetter(DeviceInformation) &&
428 !HasNoDriveLetterEntry(DeviceInformation->UniqueId))
429 {
430 /* And create one */
431 CreateNoDriveLetterEntry(DeviceInformation->UniqueId);
432 }
433
434 DeviceInformation->SuggestedDriveLetter = 0;
435 }
436 /* Suggested letter & no entry */
437 else if (DeviceInformation->SuggestedDriveLetter &&
438 !HasNoDriveLetterEntry(DeviceInformation->UniqueId))
439 {
440 /* Just create a mount point */
441 SymbolicName.Buffer = NameBuffer;
442 RtlCopyMemory(NameBuffer, DosDevices.Buffer, DosDevices.Length);
443 NameBuffer[LETTER_POSITION] = DeviceInformation->SuggestedDriveLetter;
444 NameBuffer[COLON_POSITION] = L':';
445 SymbolicName.Length =
446 SymbolicName.MaximumLength = DRIVE_LETTER_LENGTH;
447
448 MountMgrCreatePointWorker(DeviceExtension, &SymbolicName, &(DeviceInformation->DeviceName));
449 }
450 }
451 }
452
453 /*
454 * @implemented
455 */
456 NTSTATUS
457 MountMgrNextDriveLetterWorker(IN PDEVICE_EXTENSION DeviceExtension,
458 IN PUNICODE_STRING DeviceName,
459 OUT PMOUNTMGR_DRIVE_LETTER_INFORMATION DriveLetterInfo)
460 {
461 NTSTATUS Status;
462 UCHAR DriveLetter;
463 PLIST_ENTRY NextEntry;
464 PMOUNTDEV_UNIQUE_ID UniqueId;
465 BOOLEAN Removable, GptDriveLetter;
466 PDEVICE_INFORMATION DeviceInformation;
467 WCHAR NameBuffer[DRIVE_LETTER_LENGTH];
468 PSYMLINK_INFORMATION SymlinkInformation;
469 UNICODE_STRING TargetDeviceName, SymbolicName;
470
471 /* First, process suggested letters */
472 if (!DeviceExtension->ProcessedSuggestions)
473 {
474 ProcessSuggestedDriveLetters(DeviceExtension);
475 DeviceExtension->ProcessedSuggestions = TRUE;
476 }
477
478 /* Then, get information about the device */
479 Status = QueryDeviceInformation(DeviceName, &TargetDeviceName, NULL, &Removable, &GptDriveLetter, NULL, NULL, NULL);
480 if (!NT_SUCCESS(Status))
481 {
482 return Status;
483 }
484
485 /* Ensure we have such device */
486 NextEntry = DeviceExtension->DeviceListHead.Flink;
487 while (NextEntry != &(DeviceExtension->DeviceListHead))
488 {
489 DeviceInformation = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
490
491 if (RtlCompareUnicodeString(&(DeviceInformation->DeviceName), &TargetDeviceName, TRUE) == 0)
492 {
493 break;
494 }
495
496 NextEntry = NextEntry->Flink;
497 }
498
499 if (NextEntry == &(DeviceExtension->DeviceListHead))
500 {
501 FreePool(TargetDeviceName.Buffer);
502 return STATUS_OBJECT_NAME_NOT_FOUND;
503 }
504
505 /* Now, mark we have assigned a letter (assumption) */
506 DeviceInformation->LetterAssigned =
507 DriveLetterInfo->DriveLetterWasAssigned = TRUE;
508
509 /* Browse all the symlink to see if there's already a drive letter */
510 NextEntry = DeviceInformation->SymbolicLinksListHead.Flink;
511 while (NextEntry != &(DeviceInformation->SymbolicLinksListHead))
512 {
513 SymlinkInformation = CONTAINING_RECORD(NextEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
514
515 /* This is a driver letter & online one, forget about new drive eltter */
516 if (IsDriveLetter(&(SymlinkInformation->Name)) && SymlinkInformation->Online)
517 {
518 DriveLetterInfo->DriveLetterWasAssigned = FALSE;
519 DriveLetterInfo->CurrentDriveLetter = (CHAR)SymlinkInformation->Name.Buffer[LETTER_POSITION];
520 break;
521 }
522
523 NextEntry = NextEntry->Flink;
524 }
525
526 /* If we didn't find a drive letter online
527 * ensure there's no GPT drive letter nor no drive entry
528 */
529 if (NextEntry == &(DeviceInformation->SymbolicLinksListHead))
530 {
531 if (GptDriveLetter || HasNoDriveLetterEntry(DeviceInformation->UniqueId))
532 {
533 DriveLetterInfo->DriveLetterWasAssigned = FALSE;
534 DriveLetterInfo->CurrentDriveLetter = 0;
535
536 goto Release;
537 }
538 }
539
540 /* No, ensure that the device is not automonted nor removable */
541 if (!DeviceExtension->NoAutoMount && !Removable)
542 {
543 if (DriveLetterInfo->DriveLetterWasAssigned)
544 {
545 DriveLetterInfo->DriveLetterWasAssigned = FALSE;
546 DriveLetterInfo->CurrentDriveLetter = 0;
547
548 goto Release;
549 }
550 }
551
552 if (!DriveLetterInfo->DriveLetterWasAssigned)
553 {
554 goto Release;
555 }
556
557 /* Now everything is fine, start processing */
558
559 if (RtlPrefixUnicodeString(&DeviceFloppy, &TargetDeviceName, TRUE))
560 {
561 /* If the device is a floppy, start with letter A */
562 DriveLetter = 'A';
563 }
564 else if (RtlPrefixUnicodeString(&DeviceCdRom, &TargetDeviceName, TRUE))
565 {
566 /* If the device is a CD-ROM, start with letter D */
567 DriveLetter = 'D';
568 }
569 else
570 {
571 /* Finally, if it's a disk, use C */
572 DriveLetter = 'C';
573 }
574
575 /* We cannot set NO drive letter */
576 ASSERT(DeviceInformation->SuggestedDriveLetter != (UCHAR)-1);
577
578 /* If we don't have suggested letter but it's a FT volume, fail */
579 if (!DeviceInformation->SuggestedDriveLetter && IsFtVolume(&(DeviceInformation->DeviceName)))
580 {
581 DriveLetterInfo->DriveLetterWasAssigned = FALSE;
582 DriveLetterInfo->CurrentDriveLetter = 0;
583
584 goto Release;
585 }
586
587 /* Prepare buffer */
588 RtlCopyMemory(NameBuffer, DosDevices.Buffer, DosDevices.Length);
589 NameBuffer[COLON_POSITION] = L':';
590 SymbolicName.Buffer = NameBuffer;
591 SymbolicName.Length =
592 SymbolicName.MaximumLength = DRIVE_LETTER_LENGTH;
593
594 /* It's all prepared, create mount point */
595 if (DeviceInformation->SuggestedDriveLetter)
596 {
597 DriveLetterInfo->CurrentDriveLetter = DeviceInformation->SuggestedDriveLetter;
598 NameBuffer[LETTER_POSITION] = DeviceInformation->SuggestedDriveLetter;
599
600 Status = MountMgrCreatePointWorker(DeviceExtension, &SymbolicName, &TargetDeviceName);
601 if (NT_SUCCESS(Status))
602 {
603 goto Release;
604 }
605 }
606
607 /* It failed with this letter... Try another one! */
608 for (DriveLetterInfo->CurrentDriveLetter = DriveLetter;
609 DriveLetterInfo->CurrentDriveLetter <= L'Z';
610 DriveLetterInfo->CurrentDriveLetter++)
611 {
612 NameBuffer[LETTER_POSITION] = DeviceInformation->SuggestedDriveLetter;
613
614 Status = MountMgrCreatePointWorker(DeviceExtension, &SymbolicName, &TargetDeviceName);
615 if (NT_SUCCESS(Status))
616 {
617 break;
618 }
619 }
620
621 /* We failed setting a letter */
622 if (DriveLetterInfo->CurrentDriveLetter > L'Z')
623 {
624 DriveLetterInfo->DriveLetterWasAssigned = FALSE;
625 DriveLetterInfo->CurrentDriveLetter = 0;
626
627 /* Try at least to add a no drive letter entry */
628 Status = QueryDeviceInformation(&TargetDeviceName, NULL, &UniqueId, NULL, NULL, NULL, NULL, NULL);
629 if (NT_SUCCESS(Status))
630 {
631 CreateNoDriveLetterEntry(UniqueId);
632 FreePool(UniqueId);
633 }
634 }
635
636 Release:
637 FreePool(TargetDeviceName.Buffer);
638
639 return STATUS_SUCCESS;
640 }
641
642
643 /*
644 * @implemented
645 */
646 NTSTATUS
647 MountMgrNextDriveLetter(IN PDEVICE_EXTENSION DeviceExtension,
648 IN PIRP Irp)
649 {
650 NTSTATUS Status;
651 PIO_STACK_LOCATION Stack;
652 UNICODE_STRING DeviceName;
653 PMOUNTMGR_DRIVE_LETTER_TARGET DriveLetterTarget;
654 MOUNTMGR_DRIVE_LETTER_INFORMATION DriveLetterInformation;
655
656 Stack = IoGetNextIrpStackLocation(Irp);
657
658 /* Validate input */
659 if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_DRIVE_LETTER_TARGET) ||
660 Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(MOUNTMGR_DRIVE_LETTER_INFORMATION))
661 {
662 return STATUS_INVALID_PARAMETER;
663 }
664
665 DriveLetterTarget = (PMOUNTMGR_DRIVE_LETTER_TARGET)Irp->AssociatedIrp.SystemBuffer;
666 if (DriveLetterTarget->DeviceNameLength + sizeof(USHORT) > Stack->Parameters.DeviceIoControl.InputBufferLength)
667 {
668 return STATUS_INVALID_PARAMETER;
669 }
670
671 /* Call the worker */
672 DeviceName.Buffer = DriveLetterTarget->DeviceName;
673 DeviceName.Length =
674 DeviceName.MaximumLength = DriveLetterTarget->DeviceNameLength;
675
676 Status = MountMgrNextDriveLetterWorker(DeviceExtension, &DeviceName,
677 &DriveLetterInformation);
678 if (NT_SUCCESS(Status))
679 {
680 *(PMOUNTMGR_DRIVE_LETTER_INFORMATION)Irp->AssociatedIrp.SystemBuffer =
681 DriveLetterInformation;
682 Irp->IoStatus.Information = sizeof(MOUNTMGR_DRIVE_LETTER_INFORMATION);
683 }
684
685 return Status;
686 }
687
688 /*
689 * @implemented
690 */
691 NTSTATUS
692 NTAPI
693 MountMgrQuerySystemVolumeNameQueryRoutine(IN PWSTR ValueName,
694 IN ULONG ValueType,
695 IN PVOID ValueData,
696 IN ULONG ValueLength,
697 IN PVOID Context,
698 IN PVOID EntryContext)
699 {
700 UNICODE_STRING ValueString;
701 PUNICODE_STRING SystemVolumeName;
702
703 UNREFERENCED_PARAMETER(ValueName);
704 UNREFERENCED_PARAMETER(ValueLength);
705 UNREFERENCED_PARAMETER(EntryContext);
706
707 if (ValueType != REG_SZ)
708 {
709 return STATUS_SUCCESS;
710 }
711
712 RtlInitUnicodeString(&ValueString, ValueData);
713 SystemVolumeName = Context;
714
715 /* Return a string containing system volume name */
716 SystemVolumeName->Length = ValueString.Length;
717 SystemVolumeName->MaximumLength = ValueString.Length + sizeof(WCHAR);
718 SystemVolumeName->Buffer = AllocatePool(SystemVolumeName->MaximumLength);
719 if (SystemVolumeName->Buffer)
720 {
721 RtlCopyMemory(SystemVolumeName->Buffer, ValueData, ValueString.Length);
722 SystemVolumeName->Buffer[ValueString.Length / sizeof(WCHAR)] = UNICODE_NULL;
723 }
724
725 return STATUS_SUCCESS;
726
727 }
728
729 /*
730 * @implemented
731 */
732 NTSTATUS
733 MountMgrQuerySystemVolumeName(OUT PUNICODE_STRING SystemVolumeName)
734 {
735 RTL_QUERY_REGISTRY_TABLE QueryTable[2];
736
737 RtlZeroMemory(QueryTable, sizeof(QueryTable));
738 QueryTable[0].QueryRoutine = MountMgrQuerySystemVolumeNameQueryRoutine;
739 QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
740 QueryTable[0].Name = L"SystemPartition";
741
742 SystemVolumeName->Buffer = NULL;
743
744 RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
745 L"\\Registry\\Machine\\System\\Setup",
746 QueryTable,
747 SystemVolumeName,
748 NULL);
749
750 if (SystemVolumeName->Buffer)
751 {
752 return STATUS_SUCCESS;
753 }
754
755 return STATUS_UNSUCCESSFUL;
756 }
757
758 /*
759 * @implemented
760 */
761 VOID
762 MountMgrAssignDriveLetters(IN PDEVICE_EXTENSION DeviceExtension)
763 {
764 NTSTATUS Status;
765 PLIST_ENTRY NextEntry;
766 UNICODE_STRING SystemVolumeName;
767 PDEVICE_INFORMATION DeviceInformation;
768 MOUNTMGR_DRIVE_LETTER_INFORMATION DriveLetterInformation;
769
770 /* First, get system volume name */
771 Status = MountMgrQuerySystemVolumeName(&SystemVolumeName);
772
773 /* If there are no device, it's all done */
774 if (IsListEmpty(&(DeviceExtension->DeviceListHead)))
775 {
776 if (NT_SUCCESS(Status))
777 {
778 FreePool(SystemVolumeName.Buffer);
779 }
780
781 return;
782 }
783
784 /* Now, for all the devices... */
785 for (NextEntry = DeviceExtension->DeviceListHead.Flink;
786 NextEntry != &(DeviceExtension->DeviceListHead);
787 NextEntry = NextEntry->Flink)
788 {
789 DeviceInformation = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
790
791 /* If the device doesn't have a letter assigned, do it! */
792 if (!DeviceInformation->LetterAssigned)
793 {
794 MountMgrNextDriveLetterWorker(DeviceExtension,
795 &(DeviceInformation->DeviceName),
796 &DriveLetterInformation);
797 }
798
799 /* If it was the system volume */
800 if (NT_SUCCESS(Status) && RtlEqualUnicodeString(&SystemVolumeName, &(DeviceInformation->DeviceName), TRUE))
801 {
802 /* Keep track of it */
803 DeviceExtension->DriveLetterData = AllocatePool(DeviceInformation->UniqueId->UniqueIdLength +
804 sizeof(MOUNTDEV_UNIQUE_ID));
805 if (DeviceExtension->DriveLetterData)
806 {
807 RtlCopyMemory(DeviceExtension->DriveLetterData,
808 DeviceInformation->UniqueId,
809 DeviceInformation->UniqueId->UniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
810 }
811
812 /* If it was not automount, ensure it gets mounted */
813 if (!DeviceExtension->NoAutoMount)
814 {
815 DeviceExtension->NoAutoMount = TRUE;
816
817 MountMgrNextDriveLetterWorker(DeviceExtension,
818 &(DeviceInformation->DeviceName),
819 &DriveLetterInformation);
820
821 DeviceExtension->NoAutoMount = FALSE;
822 }
823 }
824 }
825
826 if (NT_SUCCESS(Status))
827 {
828 FreePool(SystemVolumeName.Buffer);
829 }
830 }
831
832 NTSTATUS
833 MountMgrQueryDosVolumePath(IN PDEVICE_EXTENSION DeviceExtension,
834 IN PIRP Irp)
835 {
836 NTSTATUS Status;
837 ULONG DevicesFound;
838 PIO_STACK_LOCATION Stack;
839 PLIST_ENTRY SymlinksEntry;
840 UNICODE_STRING SymbolicName;
841 PMOUNTMGR_TARGET_NAME Target;
842 PWSTR DeviceString, OldBuffer;
843 USHORT DeviceLength, OldLength;
844 PDEVICE_INFORMATION DeviceInformation;
845 PSYMLINK_INFORMATION SymlinkInformation;
846 PASSOCIATED_DEVICE_ENTRY AssociatedDevice;
847
848 Stack = IoGetNextIrpStackLocation(Irp);
849
850 /* Validate input size */
851 if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_TARGET_NAME))
852 {
853 return STATUS_INVALID_PARAMETER;
854 }
855
856 /* Ensure we have received UNICODE_STRING */
857 Target = (PMOUNTMGR_TARGET_NAME)Irp->AssociatedIrp.SystemBuffer;
858 if (Target->DeviceNameLength & 1)
859 {
860 return STATUS_INVALID_PARAMETER;
861 }
862
863 /* Validate the entry structure size */
864 if (Target->DeviceNameLength + sizeof(UNICODE_NULL) > Stack->Parameters.DeviceIoControl.InputBufferLength)
865 {
866 return STATUS_INVALID_PARAMETER;
867 }
868
869 /* Ensure we can at least return needed size */
870 if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))
871 {
872 return STATUS_INVALID_PARAMETER;
873 }
874
875 /* Construct string for query */
876 SymbolicName.Length = Target->DeviceNameLength;
877 SymbolicName.MaximumLength = Target->DeviceNameLength + sizeof(UNICODE_NULL);
878 SymbolicName.Buffer = Target->DeviceName;
879
880 /* Find device with our info */
881 Status = FindDeviceInfo(DeviceExtension, &SymbolicName, FALSE, &DeviceInformation);
882 if (!NT_SUCCESS(Status))
883 {
884 return Status;
885 }
886
887 DeviceLength = 0;
888 DeviceString = NULL;
889 DevicesFound = 0;
890
891 /* Try to find associated device info */
892 while (TRUE)
893 {
894 for (SymlinksEntry = DeviceInformation->SymbolicLinksListHead.Flink;
895 SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead);
896 SymlinksEntry = SymlinksEntry->Flink)
897 {
898 SymlinkInformation = CONTAINING_RECORD(SymlinksEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
899
900 /* Try to find with drive letter */
901 if (MOUNTMGR_IS_DRIVE_LETTER(&SymlinkInformation->Name) && SymlinkInformation->Online)
902 {
903 break;
904 }
905 }
906
907 /* We didn't find, break */
908 if (SymlinksEntry == &(DeviceInformation->SymbolicLinksListHead))
909 {
910 break;
911 }
912
913 /* It doesn't have associated device, go to fallback method */
914 if (IsListEmpty(&DeviceInformation->AssociatedDevicesHead))
915 {
916 goto TryWithVolumeName;
917 }
918
919 /* Create a string with the information about the device */
920 AssociatedDevice = CONTAINING_RECORD(&(DeviceInformation->SymbolicLinksListHead), ASSOCIATED_DEVICE_ENTRY, AssociatedDevicesEntry);
921 OldLength = DeviceLength;
922 OldBuffer = DeviceString;
923 DeviceLength += AssociatedDevice->String.Length;
924 DeviceString = AllocatePool(DeviceLength);
925 if (!DeviceString)
926 {
927 if (OldBuffer)
928 {
929 FreePool(OldBuffer);
930 }
931
932 return STATUS_INSUFFICIENT_RESOURCES;
933 }
934
935 /* Store our info and previous if any */
936 RtlCopyMemory(DeviceString, AssociatedDevice->String.Buffer, AssociatedDevice->String.Length);
937 if (OldBuffer)
938 {
939 RtlCopyMemory(&DeviceString[AssociatedDevice->String.Length / sizeof(WCHAR)], OldBuffer, OldLength);
940 FreePool(OldBuffer);
941 }
942
943 /* Count and continue looking */
944 ++DevicesFound;
945 DeviceInformation = AssociatedDevice->DeviceInformation;
946
947 /* If too many devices, try another way */
948 if (DevicesFound > MAX_DEVICES) /* 1000 */
949 {
950 goto TryWithVolumeName;
951 }
952 }
953
954 /* Reallocate our string, so that we can prepend disk letter */
955 OldBuffer = DeviceString;
956 OldLength = DeviceLength;
957 DeviceLength += 2 * sizeof(WCHAR);
958 DeviceString = AllocatePool(DeviceLength);
959 if (!DeviceString)
960 {
961 if (OldBuffer)
962 {
963 FreePool(OldBuffer);
964 }
965
966 return STATUS_INSUFFICIENT_RESOURCES;
967 }
968
969 /* Get the letter */
970 DeviceString[0] = SymlinkInformation->Name.Buffer[12];
971 DeviceString[1] = L':';
972
973 /* And copy the rest */
974 if (OldBuffer)
975 {
976 RtlCopyMemory(&DeviceString[2], OldBuffer, OldLength);
977 FreePool(OldBuffer);
978 }
979
980 TryWithVolumeName:
981 /* If we didn't find anything, try differently */
982 if (DeviceLength < 2 * sizeof(WCHAR) || DeviceString[1] != L':')
983 {
984 if (DeviceString)
985 {
986 FreePool(DeviceString);
987 DeviceLength = 0;
988 }
989
990 /* Try to find a volume name matching */
991 for (SymlinksEntry = DeviceInformation->SymbolicLinksListHead.Flink;
992 SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead);
993 SymlinksEntry = SymlinksEntry->Flink)
994 {
995 SymlinkInformation = CONTAINING_RECORD(SymlinksEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
996
997 if (MOUNTMGR_IS_VOLUME_NAME(&SymlinkInformation->Name))
998 {
999 break;
1000 }
1001 }
1002
1003 /* If found copy */
1004 if (SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead))
1005 {
1006 DeviceLength = SymlinkInformation->Name.Length;
1007 DeviceString = AllocatePool(DeviceLength);
1008 if (!DeviceString)
1009 {
1010 return STATUS_INSUFFICIENT_RESOURCES;
1011 }
1012
1013 RtlCopyMemory(DeviceString, SymlinkInformation->Name.Buffer, DeviceLength);
1014 /* Ensure we are in the right namespace; [1] can be ? */
1015 DeviceString[1] = L'\\';
1016 }
1017 }
1018
1019 /* If we found something */
1020 if (DeviceString)
1021 {
1022 /* At least, we will return our length */
1023 ((PMOUNTMGR_VOLUME_PATHS)Irp->AssociatedIrp.SystemBuffer)->MultiSzLength = DeviceLength;
1024 /* MOUNTMGR_VOLUME_PATHS is a string + a ULONG */
1025 Irp->IoStatus.Information = DeviceLength + sizeof(ULONG);
1026
1027 /* If we have enough room for copying the string */
1028 if (sizeof(ULONG) + DeviceLength <= Stack->Parameters.DeviceIoControl.OutputBufferLength)
1029 {
1030 /* Copy it */
1031 if (DeviceLength)
1032 {
1033 RtlCopyMemory(((PMOUNTMGR_VOLUME_PATHS)Irp->AssociatedIrp.SystemBuffer)->MultiSz, DeviceString, DeviceLength);
1034 }
1035
1036 /* And double zero at its end - this is needed in case of multiple paths which are separated by a single 0 */
1037 FreePool(DeviceString);
1038 ((PMOUNTMGR_VOLUME_PATHS)Irp->AssociatedIrp.SystemBuffer)->MultiSz[DeviceLength / sizeof(WCHAR)] = 0;
1039 ((PMOUNTMGR_VOLUME_PATHS)Irp->AssociatedIrp.SystemBuffer)->MultiSz[DeviceLength / sizeof(WCHAR) + 1] = 0;
1040
1041 return STATUS_SUCCESS;
1042 }
1043 else
1044 {
1045 /* Just return appropriate size and leave */
1046 FreePool(DeviceString);
1047 Irp->IoStatus.Information = sizeof(ULONG);
1048 return STATUS_BUFFER_OVERFLOW;
1049 }
1050 }
1051
1052 /* Fail */
1053 return STATUS_NOT_FOUND;
1054 }
1055
1056 NTSTATUS
1057 MountMgrQueryDosVolumePaths(IN PDEVICE_EXTENSION DeviceExtension,
1058 IN PIRP Irp)
1059 {
1060 UNREFERENCED_PARAMETER(DeviceExtension);
1061 UNREFERENCED_PARAMETER(Irp);
1062 return STATUS_NOT_IMPLEMENTED;
1063 }
1064
1065 /*
1066 * @implemented
1067 */
1068 NTSTATUS
1069 MountMgrKeepLinksWhenOffline(IN PDEVICE_EXTENSION DeviceExtension,
1070 IN PIRP Irp)
1071 {
1072 NTSTATUS Status;
1073 PIO_STACK_LOCATION Stack;
1074 UNICODE_STRING SymbolicName;
1075 PMOUNTMGR_TARGET_NAME Target;
1076 PDEVICE_INFORMATION DeviceInformation;
1077
1078 Stack = IoGetNextIrpStackLocation(Irp);
1079
1080 /* Validate input */
1081 if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_TARGET_NAME))
1082 {
1083 return STATUS_INVALID_PARAMETER;
1084 }
1085
1086 Target = (PMOUNTMGR_TARGET_NAME)Irp->AssociatedIrp.SystemBuffer;
1087 if (Target->DeviceNameLength + sizeof(USHORT) > Stack->Parameters.DeviceIoControl.InputBufferLength)
1088 {
1089 return STATUS_INVALID_PARAMETER;
1090 }
1091
1092 SymbolicName.Length =
1093 SymbolicName.MaximumLength = Target->DeviceNameLength;
1094 SymbolicName.Buffer = Target->DeviceName;
1095
1096 /* Find the associated device */
1097 Status = FindDeviceInfo(DeviceExtension, &SymbolicName, FALSE, &DeviceInformation);
1098 if (!NT_SUCCESS(Status))
1099 {
1100 return Status;
1101 }
1102
1103 /* Mark we want to keep links */
1104 DeviceInformation->KeepLinks = TRUE;
1105
1106 return STATUS_SUCCESS;
1107 }
1108
1109 /*
1110 * @implemented
1111 */
1112 NTSTATUS
1113 MountMgrVolumeArrivalNotification(IN PDEVICE_EXTENSION DeviceExtension,
1114 IN PIRP Irp)
1115 {
1116 NTSTATUS Status;
1117 BOOLEAN OldState;
1118 PIO_STACK_LOCATION Stack;
1119 UNICODE_STRING SymbolicName;
1120 PMOUNTMGR_TARGET_NAME Target;
1121
1122 Stack = IoGetNextIrpStackLocation(Irp);
1123
1124 /* Validate input */
1125 if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_TARGET_NAME))
1126 {
1127 return STATUS_INVALID_PARAMETER;
1128 }
1129
1130 Target = (PMOUNTMGR_TARGET_NAME)Irp->AssociatedIrp.SystemBuffer;
1131 if (Target->DeviceNameLength + sizeof(USHORT) > Stack->Parameters.DeviceIoControl.InputBufferLength)
1132 {
1133 return STATUS_INVALID_PARAMETER;
1134 }
1135
1136 SymbolicName.Length =
1137 SymbolicName.MaximumLength = Target->DeviceNameLength;
1138 SymbolicName.Buffer = Target->DeviceName;
1139
1140 /* Disable hard errors */
1141 OldState = PsGetThreadHardErrorsAreDisabled(PsGetCurrentThread());
1142 PsSetThreadHardErrorsAreDisabled(PsGetCurrentThread(), TRUE);
1143
1144 /* Call real worker */
1145 Status = MountMgrMountedDeviceArrival(DeviceExtension, &SymbolicName, TRUE);
1146
1147 PsSetThreadHardErrorsAreDisabled(PsGetCurrentThread(), OldState);
1148
1149 return Status;
1150 }
1151
1152 /*
1153 * @implemented
1154 */
1155 NTSTATUS
1156 MountMgrQueryPoints(IN PDEVICE_EXTENSION DeviceExtension,
1157 IN PIRP Irp)
1158 {
1159 NTSTATUS Status;
1160 PIO_STACK_LOCATION Stack;
1161 PMOUNTDEV_UNIQUE_ID UniqueId;
1162 PMOUNTMGR_MOUNT_POINT MountPoint;
1163 UNICODE_STRING SymbolicName, DeviceName;
1164
1165 Stack = IoGetNextIrpStackLocation(Irp);
1166
1167 /* Validate input... */
1168 if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_MOUNT_POINT))
1169 {
1170 return STATUS_INVALID_PARAMETER;
1171 }
1172
1173 MountPoint = (PMOUNTMGR_MOUNT_POINT)Irp->AssociatedIrp.SystemBuffer;
1174 if (!MountPoint->SymbolicLinkNameLength)
1175 {
1176 MountPoint->SymbolicLinkNameOffset = 0;
1177 }
1178
1179 if (!MountPoint->UniqueIdLength)
1180 {
1181 MountPoint->UniqueIdOffset = 0;
1182 }
1183
1184 if (!MountPoint->DeviceNameLength)
1185 {
1186 MountPoint->DeviceNameOffset = 0;
1187 }
1188
1189 /* Addresses can't be odd */
1190 if ((MountPoint->SymbolicLinkNameOffset & 1) ||
1191 (MountPoint->SymbolicLinkNameLength & 1))
1192 {
1193 return STATUS_INVALID_PARAMETER;
1194 }
1195
1196 if ((MountPoint->UniqueIdOffset & 1) ||
1197 (MountPoint->UniqueIdLength & 1))
1198 {
1199 return STATUS_INVALID_PARAMETER;
1200 }
1201
1202 if ((MountPoint->DeviceNameOffset & 1) ||
1203 (MountPoint->DeviceNameLength & 1))
1204 {
1205 return STATUS_INVALID_PARAMETER;
1206 }
1207
1208 /* We can't go beyond */
1209 if (((ULONG)MountPoint->SymbolicLinkNameLength + MountPoint->UniqueIdLength +
1210 MountPoint->DeviceNameLength) < Stack->Parameters.DeviceIoControl.InputBufferLength)
1211 {
1212 return STATUS_INVALID_PARAMETER;
1213 }
1214
1215 if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(MOUNTMGR_MOUNT_POINTS))
1216 {
1217 return STATUS_INVALID_PARAMETER;
1218 }
1219
1220 /* If caller provided a Symlink, use it */
1221 if (MountPoint->SymbolicLinkNameLength != 0)
1222 {
1223 if (MountPoint->SymbolicLinkNameLength > MAXSHORT)
1224 {
1225 return STATUS_INVALID_PARAMETER;
1226 }
1227
1228 SymbolicName.Length = MountPoint->SymbolicLinkNameLength;
1229 SymbolicName.MaximumLength = MountPoint->SymbolicLinkNameLength + sizeof(WCHAR);
1230 SymbolicName.Buffer = AllocatePool(SymbolicName.MaximumLength);
1231 if (!SymbolicName.Buffer)
1232 {
1233 return STATUS_INSUFFICIENT_RESOURCES;
1234 }
1235
1236 RtlCopyMemory(SymbolicName.Buffer,
1237 (PWSTR)((ULONG_PTR)MountPoint + MountPoint->SymbolicLinkNameOffset),
1238 SymbolicName.Length);
1239 SymbolicName.Buffer[SymbolicName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1240
1241 /* Query links using it */
1242 Status = QueryPointsFromSymbolicLinkName(DeviceExtension, &SymbolicName, Irp);
1243 FreePool(SymbolicName.Buffer);
1244 }
1245 /* If user provided an unique ID */
1246 else if (MountPoint->UniqueIdLength != 0)
1247 {
1248 UniqueId = AllocatePool(MountPoint->UniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
1249 if (!UniqueId)
1250 {
1251 return STATUS_INSUFFICIENT_RESOURCES;
1252 }
1253
1254 UniqueId->UniqueIdLength = MountPoint->UniqueIdLength;
1255 RtlCopyMemory(UniqueId->UniqueId,
1256 (PVOID)((ULONG_PTR)MountPoint + MountPoint->UniqueIdOffset),
1257 MountPoint->UniqueIdLength);
1258
1259 /* Query links using it */
1260 Status = QueryPointsFromMemory(DeviceExtension, Irp, UniqueId, NULL);
1261 FreePool(UniqueId);
1262 }
1263 /* If caller provided a device name */
1264 else if (MountPoint->DeviceNameLength != 0)
1265 {
1266 if (MountPoint->DeviceNameLength > MAXSHORT)
1267 {
1268 return STATUS_INVALID_PARAMETER;
1269 }
1270
1271 DeviceName.Length = MountPoint->DeviceNameLength;
1272 DeviceName.MaximumLength = MountPoint->DeviceNameLength + sizeof(WCHAR);
1273 DeviceName.Buffer = AllocatePool(DeviceName.MaximumLength);
1274 if (!DeviceName.Buffer)
1275 {
1276 return STATUS_INSUFFICIENT_RESOURCES;
1277 }
1278
1279 RtlCopyMemory(DeviceName.Buffer,
1280 (PWSTR)((ULONG_PTR)MountPoint + MountPoint->DeviceNameOffset),
1281 DeviceName.Length);
1282 DeviceName.Buffer[DeviceName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1283
1284 /* Query links using it */
1285 Status = QueryPointsFromMemory(DeviceExtension, Irp, NULL, &DeviceName);
1286 FreePool(DeviceName.Buffer);
1287 }
1288 else
1289 {
1290 /* Otherwise, query all links */
1291 Status = QueryPointsFromMemory(DeviceExtension, Irp, NULL, NULL);
1292 }
1293
1294 return Status;
1295 }
1296
1297 /*
1298 * @implemented
1299 */
1300 NTSTATUS
1301 MountMgrDeletePoints(IN PDEVICE_EXTENSION DeviceExtension,
1302 IN PIRP Irp)
1303 {
1304 ULONG Link;
1305 NTSTATUS Status;
1306 BOOLEAN CreateNoDrive;
1307 PIO_STACK_LOCATION Stack;
1308 PMOUNTDEV_UNIQUE_ID UniqueId;
1309 PMOUNTMGR_MOUNT_POINT MountPoint;
1310 PMOUNTMGR_MOUNT_POINTS MountPoints;
1311 UNICODE_STRING SymbolicName, DeviceName;
1312
1313 Stack = IoGetNextIrpStackLocation(Irp);
1314
1315 /* Validate input */
1316 if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_MOUNT_POINT))
1317 {
1318 return STATUS_INVALID_PARAMETER;
1319 }
1320
1321 /* Query points */
1322 MountPoint = (PMOUNTMGR_MOUNT_POINT)Irp->AssociatedIrp.SystemBuffer;
1323 CreateNoDrive = (MountPoint->SymbolicLinkNameOffset && MountPoint->SymbolicLinkNameLength);
1324
1325 Status = MountMgrQueryPoints(DeviceExtension, Irp);
1326 if (!NT_SUCCESS(Status))
1327 {
1328 return Status;
1329 }
1330
1331 /* For all the points matching the request */
1332 MountPoints = (PMOUNTMGR_MOUNT_POINTS)Irp->AssociatedIrp.SystemBuffer;
1333 for (Link = 0; Link < MountPoints->NumberOfMountPoints; Link++)
1334 {
1335 SymbolicName.Length = MountPoints->MountPoints[Link].SymbolicLinkNameLength;
1336 SymbolicName.MaximumLength = SymbolicName.Length + sizeof(WCHAR);
1337 SymbolicName.Buffer = AllocatePool(SymbolicName.MaximumLength);
1338 if (!SymbolicName.Buffer)
1339 {
1340 return STATUS_INSUFFICIENT_RESOURCES;
1341 }
1342
1343 RtlCopyMemory(SymbolicName.Buffer,
1344 (PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[Link].SymbolicLinkNameOffset),
1345 SymbolicName.Length);
1346 SymbolicName.Buffer[SymbolicName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1347
1348 /* Create a no drive entry for the drive letters */
1349 if (CreateNoDrive && IsDriveLetter(&SymbolicName))
1350 {
1351 UniqueId = AllocatePool(MountPoints->MountPoints[Link].UniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
1352 if (UniqueId)
1353 {
1354 UniqueId->UniqueIdLength = MountPoints->MountPoints[Link].UniqueIdLength;
1355 RtlCopyMemory(UniqueId->UniqueId,
1356 (PMOUNTDEV_UNIQUE_ID)((ULONG_PTR)MountPoints + MountPoints->MountPoints[Link].UniqueIdOffset),
1357 MountPoints->MountPoints[Link].UniqueIdLength);
1358
1359 CreateNoDriveLetterEntry(UniqueId);
1360 FreePool(UniqueId);
1361 }
1362 }
1363
1364 /* If there are no link any more, and no need to create a no drive entry */
1365 if (Link == 0 && !CreateNoDrive)
1366 {
1367 /* Then, delete everything */
1368 UniqueId = AllocatePool(MountPoints->MountPoints[Link].UniqueIdLength);
1369 if (UniqueId)
1370 {
1371 RtlCopyMemory(UniqueId,
1372 (PMOUNTDEV_UNIQUE_ID)((ULONG_PTR)MountPoints + MountPoints->MountPoints[Link].UniqueIdOffset),
1373 MountPoints->MountPoints[Link].UniqueIdLength);
1374
1375 DeleteNoDriveLetterEntry(UniqueId);
1376 FreePool(UniqueId);
1377 }
1378 }
1379
1380 /* Delete all the information about the mount point */
1381 GlobalDeleteSymbolicLink(&SymbolicName);
1382 DeleteSymbolicLinkNameFromMemory(DeviceExtension, &SymbolicName, FALSE);
1383 RtlDeleteRegistryValue(RTL_REGISTRY_ABSOLUTE, DatabasePath, SymbolicName.Buffer);
1384 FreePool(SymbolicName.Buffer);
1385
1386 /* Notify the change */
1387 DeviceName.Length = DeviceName.MaximumLength =
1388 MountPoints->MountPoints[Link].DeviceNameLength;
1389 DeviceName.Buffer = (PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[Link].DeviceNameOffset);
1390 MountMgrNotifyNameChange(DeviceExtension, &DeviceName, TRUE);
1391 }
1392
1393 MountMgrNotify(DeviceExtension);
1394
1395 return Status;
1396 }
1397
1398 /*
1399 * @implemented
1400 */
1401 NTSTATUS
1402 MountMgrDeletePointsDbOnly(IN PDEVICE_EXTENSION DeviceExtension,
1403 IN PIRP Irp)
1404 {
1405 ULONG Link;
1406 NTSTATUS Status;
1407 UNICODE_STRING SymbolicName;
1408 PMOUNTDEV_UNIQUE_ID UniqueId;
1409 PMOUNTMGR_MOUNT_POINTS MountPoints;
1410
1411 /* Query points */
1412 Status = MountMgrQueryPoints(DeviceExtension, Irp);
1413 if (!NT_SUCCESS(Status))
1414 {
1415 return Status;
1416 }
1417
1418 MountPoints = (PMOUNTMGR_MOUNT_POINTS)Irp->AssociatedIrp.SystemBuffer;
1419 if (MountPoints->NumberOfMountPoints == 0)
1420 {
1421 return Status;
1422 }
1423
1424 /* For all the mount points */
1425 for (Link = 0; Link < MountPoints->NumberOfMountPoints; Link++)
1426 {
1427 SymbolicName.Length = MountPoints->MountPoints[Link].SymbolicLinkNameLength;
1428 SymbolicName.MaximumLength = SymbolicName.Length + sizeof(WCHAR);
1429 SymbolicName.Buffer = AllocatePool(SymbolicName.MaximumLength);
1430 if (!SymbolicName.Buffer)
1431 {
1432 return STATUS_INSUFFICIENT_RESOURCES;
1433 }
1434
1435 RtlCopyMemory(SymbolicName.Buffer,
1436 (PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[Link].SymbolicLinkNameOffset),
1437 SymbolicName.Length);
1438 SymbolicName.Buffer[SymbolicName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1439
1440 /* If the only mount point is a drive letter, then create a no letter drive entry */
1441 if (MountPoints->NumberOfMountPoints == 1 && IsDriveLetter(&SymbolicName))
1442 {
1443 UniqueId = AllocatePool(MountPoints->MountPoints[Link].UniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
1444 if (UniqueId)
1445 {
1446 UniqueId->UniqueIdLength = MountPoints->MountPoints[Link].UniqueIdLength;
1447 RtlCopyMemory(UniqueId->UniqueId,
1448 (PMOUNTDEV_UNIQUE_ID)((ULONG_PTR)MountPoints + MountPoints->MountPoints[Link].UniqueIdOffset),
1449 MountPoints->MountPoints[Link].UniqueIdLength);
1450
1451 CreateNoDriveLetterEntry(UniqueId);
1452 FreePool(UniqueId);
1453 }
1454 }
1455
1456 /* Simply delete mount point from DB */
1457 DeleteSymbolicLinkNameFromMemory(DeviceExtension, &SymbolicName, TRUE);
1458 RtlDeleteRegistryValue(RTL_REGISTRY_ABSOLUTE, DatabasePath, SymbolicName.Buffer);
1459 FreePool(SymbolicName.Buffer);
1460 }
1461
1462 return Status;
1463 }
1464
1465 /*
1466 * @implemented
1467 */
1468 NTSTATUS
1469 MountMgrVolumeMountPointChanged(IN PDEVICE_EXTENSION DeviceExtension,
1470 IN PIRP Irp,
1471 IN NTSTATUS LockStatus,
1472 OUT PUNICODE_STRING SourceDeviceName,
1473 OUT PUNICODE_STRING SourceSymbolicName,
1474 OUT PUNICODE_STRING TargetVolumeName)
1475 {
1476 HANDLE Handle;
1477 NTSTATUS Status;
1478 PFILE_OBJECT FileObject;
1479 PIO_STACK_LOCATION Stack;
1480 ULONG Length, SavedLength;
1481 BOOLEAN FOReferenced = FALSE;
1482 IO_STATUS_BLOCK IoStatusBlock;
1483 OBJECT_ATTRIBUTES ObjectAttributes;
1484 PDEVICE_INFORMATION DeviceInformation;
1485 OBJECT_NAME_INFORMATION ObjectNameInfo;
1486 FILE_FS_DEVICE_INFORMATION FsDeviceInfo;
1487 PFILE_NAME_INFORMATION FileNameInfo = NULL;
1488 PMOUNTMGR_VOLUME_MOUNT_POINT VolumeMountPoint;
1489 POBJECT_NAME_INFORMATION ObjectNameInfoPtr = NULL;
1490 UNICODE_STRING SourceVolumeName, TargetDeviceName;
1491
1492 Stack = IoGetNextIrpStackLocation(Irp);
1493
1494 /* Validate input */
1495 if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_VOLUME_MOUNT_POINT))
1496 {
1497 return STATUS_INVALID_PARAMETER;
1498 }
1499
1500 VolumeMountPoint = (PMOUNTMGR_VOLUME_MOUNT_POINT)Irp->AssociatedIrp.SystemBuffer;
1501
1502 if (((ULONG)VolumeMountPoint->SourceVolumeNameLength + VolumeMountPoint->TargetVolumeNameLength) <
1503 Stack->Parameters.DeviceIoControl.InputBufferLength)
1504 {
1505 return STATUS_INVALID_PARAMETER;
1506 }
1507
1508 /* Get source volume name */
1509 SourceVolumeName.Length =
1510 SourceVolumeName.MaximumLength = VolumeMountPoint->SourceVolumeNameLength;
1511 SourceVolumeName.Buffer = (PWSTR)((ULONG_PTR)VolumeMountPoint + VolumeMountPoint->SourceVolumeNameOffset);
1512
1513 InitializeObjectAttributes(&ObjectAttributes,
1514 &SourceVolumeName,
1515 OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
1516 NULL,
1517 NULL);
1518
1519 /* Open it */
1520 Status = ZwOpenFile(&Handle,
1521 SYNCHRONIZE | FILE_READ_ATTRIBUTES,
1522 &ObjectAttributes,
1523 &IoStatusBlock,
1524 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1525 FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_REPARSE_POINT);
1526 if (!NT_SUCCESS(Status))
1527 {
1528 return Status;
1529 }
1530
1531 TargetDeviceName.Buffer = NULL;
1532
1533 /* Query its attributes */
1534 Status = ZwQueryVolumeInformationFile(Handle,
1535 &IoStatusBlock,
1536 &FsDeviceInfo,
1537 sizeof(FsDeviceInfo),
1538 FileFsDeviceInformation);
1539 if (!NT_SUCCESS(Status))
1540 {
1541 goto Cleanup;
1542 }
1543
1544 if (FsDeviceInfo.DeviceType != FILE_DEVICE_DISK && FsDeviceInfo.DeviceType != FILE_DEVICE_VIRTUAL_DISK)
1545 {
1546 goto Cleanup;
1547 }
1548
1549 if (FsDeviceInfo.Characteristics != (FILE_REMOTE_DEVICE | FILE_REMOVABLE_MEDIA))
1550 {
1551 goto Cleanup;
1552 }
1553
1554 /* Reference it */
1555 Status = ObReferenceObjectByHandle(Handle, 0, *IoFileObjectType, KernelMode, (PVOID *)&FileObject, NULL);
1556 if (!NT_SUCCESS(Status))
1557 {
1558 goto Cleanup;
1559 }
1560 FOReferenced = TRUE;
1561
1562 /* Get file name */
1563 FileNameInfo = AllocatePool(sizeof(FILE_NAME_INFORMATION));
1564 if (!FileNameInfo)
1565 {
1566 Status = STATUS_INSUFFICIENT_RESOURCES;
1567 goto Cleanup;
1568 }
1569
1570 Status = ZwQueryInformationFile(Handle, &IoStatusBlock, FileNameInfo,
1571 sizeof(FILE_NAME_INFORMATION),
1572 FileNameInformation);
1573 if (Status == STATUS_BUFFER_OVERFLOW)
1574 {
1575 /* Now we have real length, use it */
1576 Length = FileNameInfo->FileNameLength;
1577 FreePool(FileNameInfo);
1578
1579 FileNameInfo = AllocatePool(sizeof(FILE_NAME_INFORMATION) + Length);
1580 if (!FileNameInfo)
1581 {
1582 Status = STATUS_INSUFFICIENT_RESOURCES;
1583 goto Cleanup;
1584 }
1585
1586 /* Really query file name */
1587 Status = ZwQueryInformationFile(Handle, &IoStatusBlock, FileNameInfo,
1588 sizeof(FILE_NAME_INFORMATION) + Length,
1589 FileNameInformation);
1590 }
1591
1592 if (!NT_SUCCESS(Status))
1593 {
1594 goto Cleanup;
1595 }
1596
1597 /* Get symbolic name */
1598 ObjectNameInfoPtr = &ObjectNameInfo;
1599 SavedLength = sizeof(OBJECT_NAME_INFORMATION);
1600 Status = ObQueryNameString(FileObject->DeviceObject, ObjectNameInfoPtr, sizeof(OBJECT_NAME_INFORMATION), &Length);
1601 if (Status == STATUS_INFO_LENGTH_MISMATCH)
1602 {
1603 /* Once again, with proper size, it works better */
1604 ObjectNameInfoPtr = AllocatePool(Length);
1605 if (!ObjectNameInfoPtr)
1606 {
1607 Status = STATUS_INSUFFICIENT_RESOURCES;
1608 goto Cleanup;
1609 }
1610
1611 SavedLength = Length;
1612 Status = ObQueryNameString(FileObject->DeviceObject, ObjectNameInfoPtr, SavedLength, &Length);
1613 }
1614
1615 if (!NT_SUCCESS(Status))
1616 {
1617 goto Cleanup;
1618 }
1619
1620 /* Now, query the device name */
1621 Status = QueryDeviceInformation(&ObjectNameInfoPtr->Name, SourceDeviceName,
1622 NULL, NULL, NULL, NULL, NULL, NULL);
1623 if (!NT_SUCCESS(Status))
1624 {
1625 goto Cleanup;
1626 }
1627
1628 /* For target volume name, use input */
1629 TargetVolumeName->Length =
1630 TargetVolumeName->MaximumLength = VolumeMountPoint->TargetVolumeNameLength;
1631 TargetVolumeName->Buffer = (PWSTR)((ULONG_PTR)VolumeMountPoint + VolumeMountPoint->TargetVolumeNameOffset);
1632
1633 /* Query its device name */
1634 Status = QueryDeviceInformation(TargetVolumeName, &TargetDeviceName,
1635 NULL, NULL, NULL, NULL, NULL, NULL);
1636 if (!NT_SUCCESS(Status))
1637 {
1638 goto Cleanup;
1639 }
1640
1641 /* Return symbolic name */
1642 SourceSymbolicName->Length =
1643 SourceSymbolicName->MaximumLength = (USHORT)FileNameInfo->FileNameLength;
1644 SourceSymbolicName->Buffer = (PWSTR)FileNameInfo;
1645 /* memmove allows memory overlap */
1646 RtlMoveMemory(SourceSymbolicName->Buffer, FileNameInfo->FileName, SourceSymbolicName->Length);
1647 FileNameInfo = NULL;
1648
1649 /* Notify the change */
1650 MountMgrNotify(DeviceExtension);
1651 MountMgrNotifyNameChange(DeviceExtension, &TargetDeviceName, TRUE);
1652
1653 /* If we are locked, sync databases if possible */
1654 if (NT_SUCCESS(LockStatus))
1655 {
1656 Status = FindDeviceInfo(DeviceExtension, SourceDeviceName, FALSE, &DeviceInformation);
1657 if (NT_SUCCESS(Status))
1658 {
1659 ReconcileThisDatabaseWithMaster(DeviceExtension, DeviceInformation);
1660 }
1661 else
1662 {
1663 Status = STATUS_PENDING;
1664 }
1665 }
1666
1667 Cleanup:
1668 if (TargetDeviceName.Buffer)
1669 {
1670 FreePool(TargetDeviceName.Buffer);
1671 }
1672
1673 if (ObjectNameInfoPtr && ObjectNameInfoPtr != &ObjectNameInfo)
1674 {
1675 FreePool(ObjectNameInfoPtr);
1676 }
1677
1678 if (FileNameInfo)
1679 {
1680 FreePool(FileNameInfo);
1681 }
1682
1683 if (FOReferenced)
1684 {
1685 ObDereferenceObject(FileObject);
1686 }
1687
1688 return Status;
1689 }
1690
1691 NTSTATUS
1692 MountMgrVolumeMountPointCreated(IN PDEVICE_EXTENSION DeviceExtension,
1693 IN PIRP Irp,
1694 IN NTSTATUS LockStatus)
1695 {
1696 UNREFERENCED_PARAMETER(DeviceExtension);
1697 UNREFERENCED_PARAMETER(Irp);
1698 UNREFERENCED_PARAMETER(LockStatus);
1699 return STATUS_NOT_IMPLEMENTED;
1700 }
1701
1702 NTSTATUS
1703 MountMgrVolumeMountPointDeleted(IN PDEVICE_EXTENSION DeviceExtension,
1704 IN PIRP Irp,
1705 IN NTSTATUS LockStatus)
1706 {
1707 UNREFERENCED_PARAMETER(DeviceExtension);
1708 UNREFERENCED_PARAMETER(Irp);
1709 UNREFERENCED_PARAMETER(LockStatus);
1710 return STATUS_NOT_IMPLEMENTED;
1711 }
1712
1713 /*
1714 * @implemented
1715 */
1716 NTSTATUS
1717 NTAPI
1718 MountMgrDeviceControl(IN PDEVICE_OBJECT DeviceObject,
1719 IN PIRP Irp)
1720 {
1721 PIO_STACK_LOCATION Stack;
1722 NTSTATUS Status, LockStatus;
1723 PDEVICE_EXTENSION DeviceExtension;
1724
1725 Stack = IoGetNextIrpStackLocation(Irp);
1726 DeviceExtension = DeviceObject->DeviceExtension;
1727
1728 KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
1729
1730 switch (Stack->Parameters.DeviceIoControl.IoControlCode)
1731 {
1732 case IOCTL_MOUNTMGR_CREATE_POINT:
1733 Status = MountMgrCreatePoint(DeviceExtension, Irp);
1734 break;
1735
1736 case IOCTL_MOUNTMGR_DELETE_POINTS:
1737 Status = MountMgrDeletePoints(DeviceExtension, Irp);
1738 break;
1739
1740 case IOCTL_MOUNTMGR_QUERY_POINTS:
1741 Status = MountMgrQueryPoints(DeviceExtension, Irp);
1742 break;
1743
1744 case IOCTL_MOUNTMGR_DELETE_POINTS_DBONLY:
1745 Status = MountMgrDeletePointsDbOnly(DeviceExtension, Irp);
1746 break;
1747
1748 case IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER:
1749 Status = MountMgrNextDriveLetter(DeviceExtension, Irp);
1750 break;
1751
1752 case IOCTL_MOUNTMGR_AUTO_DL_ASSIGNMENTS:
1753 DeviceExtension->AutomaticDriveLetter = TRUE;
1754 Status = STATUS_SUCCESS;
1755
1756 MountMgrAssignDriveLetters(DeviceExtension);
1757 ReconcileAllDatabasesWithMaster(DeviceExtension);
1758 WaitForOnlinesToComplete(DeviceExtension);
1759 break;
1760
1761 case IOCTL_MOUNTMGR_VOLUME_MOUNT_POINT_CREATED:
1762 KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
1763
1764 LockStatus = WaitForRemoteDatabaseSemaphore(DeviceExtension);
1765 KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
1766 Status = MountMgrVolumeMountPointCreated(DeviceExtension, Irp, LockStatus);
1767 if (NT_SUCCESS(LockStatus))
1768 {
1769 ReleaseRemoteDatabaseSemaphore(DeviceExtension);
1770 }
1771
1772 break;
1773
1774 case IOCTL_MOUNTMGR_VOLUME_MOUNT_POINT_DELETED:
1775 KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
1776
1777 LockStatus = WaitForRemoteDatabaseSemaphore(DeviceExtension);
1778 KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
1779 Status = MountMgrVolumeMountPointDeleted(DeviceExtension, Irp, LockStatus);
1780 if (NT_SUCCESS(LockStatus))
1781 {
1782 ReleaseRemoteDatabaseSemaphore(DeviceExtension);
1783 }
1784
1785 break;
1786
1787 case IOCTL_MOUNTMGR_CHANGE_NOTIFY:
1788 Status = MountMgrChangeNotify(DeviceExtension, Irp);
1789 break;
1790
1791 case IOCTL_MOUNTMGR_KEEP_LINKS_WHEN_OFFLINE:
1792 Status = MountMgrKeepLinksWhenOffline(DeviceExtension, Irp);
1793 break;
1794
1795 case IOCTL_MOUNTMGR_CHECK_UNPROCESSED_VOLUMES:
1796 Status = MountMgrCheckUnprocessedVolumes(DeviceExtension, Irp);
1797 goto Complete;
1798
1799 case IOCTL_MOUNTMGR_VOLUME_ARRIVAL_NOTIFICATION:
1800 KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
1801 Status = MountMgrVolumeArrivalNotification(DeviceExtension, Irp);
1802 goto Complete;
1803
1804 case IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH:
1805 Status = MountMgrQueryDosVolumePath(DeviceExtension, Irp);
1806 break;
1807
1808 case IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATHS:
1809 Status = MountMgrQueryDosVolumePaths(DeviceExtension, Irp);
1810 break;
1811
1812 case IOCTL_MOUNTMGR_SCRUB_REGISTRY:
1813 Status = MountMgrScrubRegistry(DeviceExtension);
1814 break;
1815
1816 case IOCTL_MOUNTMGR_QUERY_AUTO_MOUNT:
1817 Status = MountMgrQueryAutoMount(DeviceExtension, Irp);
1818 break;
1819
1820 case IOCTL_MOUNTMGR_SET_AUTO_MOUNT:
1821 Status = MountMgrSetAutoMount(DeviceExtension, Irp);
1822 break;
1823
1824 default:
1825 Status = STATUS_INVALID_DEVICE_REQUEST;
1826 }
1827
1828 KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
1829
1830 if (Status != STATUS_PENDING)
1831 {
1832 goto Complete;
1833 }
1834
1835 return Status;
1836
1837 Complete:
1838 Irp->IoStatus.Status = Status;
1839 IoCompleteRequest(Irp, IO_NO_INCREMENT);
1840
1841 return Status;
1842 }