6e094ed2fdb6bdfff2f37b68510c745bb267f149
[reactos.git] / reactos / drivers / storage / disk / disk.c
1 /*
2 * ReactOS kernel
3 * Copyright (C) 2001, 2002 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., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19 /* $Id: disk.c,v 1.10 2002/03/20 19:54:06 ekohl Exp $
20 *
21 * COPYRIGHT: See COPYING in the top level directory
22 * PROJECT: ReactOS kernel
23 * FILE: services/storage/disk/disk.c
24 * PURPOSE: disk class driver
25 * PROGRAMMER: Eric Kohl (ekohl@rz-online.de)
26 */
27
28 /* INCLUDES *****************************************************************/
29
30 #include <ddk/ntddk.h>
31
32 #include "../include/scsi.h"
33 #include "../include/class2.h"
34 #include "../include/ntddscsi.h"
35
36 #define NDEBUG
37 #include <debug.h>
38
39 #define VERSION "0.0.1"
40
41
42 typedef struct _DISK_DATA
43 {
44 ULONG HiddenSectors;
45 ULONG PartitionNumber;
46 UCHAR PartitionType;
47 BOOLEAN BootIndicator;
48 BOOLEAN DriveNotReady;
49 } DISK_DATA, *PDISK_DATA;
50
51
52 BOOLEAN STDCALL
53 DiskClassFindDevices(PDRIVER_OBJECT DriverObject,
54 PUNICODE_STRING RegistryPath,
55 PCLASS_INIT_DATA InitializationData,
56 PDEVICE_OBJECT PortDeviceObject,
57 ULONG PortNumber);
58
59 BOOLEAN STDCALL
60 DiskClassCheckDevice(IN PINQUIRYDATA InquiryData);
61
62 NTSTATUS STDCALL
63 DiskClassCheckReadWrite(IN PDEVICE_OBJECT DeviceObject,
64 IN PIRP Irp);
65
66
67 static NTSTATUS
68 DiskClassCreateDeviceObject(IN PDRIVER_OBJECT DriverObject,
69 IN PUNICODE_STRING RegistryPath, /* what's this used for? */
70 IN PDEVICE_OBJECT PortDeviceObject,
71 IN ULONG PortNumber,
72 IN ULONG DiskNumber,
73 IN PIO_SCSI_CAPABILITIES Capabilities,
74 IN PSCSI_INQUIRY_DATA InquiryData,
75 IN PCLASS_INIT_DATA InitializationData);
76
77 NTSTATUS STDCALL
78 DiskClassDeviceControl(IN PDEVICE_OBJECT DeviceObject,
79 IN PIRP Irp);
80
81 NTSTATUS STDCALL
82 DiskClassShutdownFlush(IN PDEVICE_OBJECT DeviceObject,
83 IN PIRP Irp);
84
85
86
87 /* FUNCTIONS ****************************************************************/
88
89 // DriverEntry
90 //
91 // DESCRIPTION:
92 // This function initializes the driver, locates and claims
93 // hardware resources, and creates various NT objects needed
94 // to process I/O requests.
95 //
96 // RUN LEVEL:
97 // PASSIVE_LEVEL
98 //
99 // ARGUMENTS:
100 // IN PDRIVER_OBJECT DriverObject System allocated Driver Object
101 // for this driver
102 // IN PUNICODE_STRING RegistryPath Name of registry driver service
103 // key
104 //
105 // RETURNS:
106 // NTSTATUS
107
108 NTSTATUS STDCALL
109 DriverEntry(IN PDRIVER_OBJECT DriverObject,
110 IN PUNICODE_STRING RegistryPath)
111 {
112 CLASS_INIT_DATA InitData;
113
114 DbgPrint("Disk Class Driver %s\n",
115 VERSION);
116 DPRINT("RegistryPath '%wZ'\n",
117 RegistryPath);
118
119 RtlZeroMemory(&InitData,
120 sizeof(CLASS_INIT_DATA));
121
122 InitData.InitializationDataSize = sizeof(CLASS_INIT_DATA);
123 InitData.DeviceExtensionSize = sizeof(DEVICE_EXTENSION) + sizeof(DISK_DATA);
124 InitData.DeviceType = FILE_DEVICE_DISK;
125 InitData.DeviceCharacteristics = 0;
126
127 InitData.ClassError = NULL; // DiskClassProcessError;
128 InitData.ClassReadWriteVerification = DiskClassCheckReadWrite;
129 InitData.ClassFindDeviceCallBack = DiskClassCheckDevice;
130 InitData.ClassFindDevices = DiskClassFindDevices;
131 InitData.ClassDeviceControl = DiskClassDeviceControl;
132 InitData.ClassShutdownFlush = DiskClassShutdownFlush;
133 InitData.ClassCreateClose = NULL;
134 InitData.ClassStartIo = NULL;
135
136 return(ScsiClassInitialize(DriverObject,
137 RegistryPath,
138 &InitData));
139 }
140
141
142 /**********************************************************************
143 * NAME EXPORTED
144 * DiskClassFindDevices
145 *
146 * DESCRIPTION
147 * This function searches for device that are attached to the
148 * given scsi port.
149 *
150 * RUN LEVEL
151 * PASSIVE_LEVEL
152 *
153 * ARGUMENTS
154 * DriverObject
155 * System allocated Driver Object for this driver
156 *
157 * RegistryPath
158 * Name of registry driver service key
159 *
160 * InitializationData
161 * Pointer to the main initialization data
162 *
163 * PortDeviceObject
164 * Pointer to the port Device Object
165 *
166 * PortNumber
167 * Port number
168 *
169 * RETURN VALUE
170 * TRUE: At least one disk drive was found
171 * FALSE: No disk drive found
172 */
173
174 BOOLEAN STDCALL
175 DiskClassFindDevices(PDRIVER_OBJECT DriverObject,
176 PUNICODE_STRING RegistryPath,
177 PCLASS_INIT_DATA InitializationData,
178 PDEVICE_OBJECT PortDeviceObject,
179 ULONG PortNumber)
180 {
181 PCONFIGURATION_INFORMATION ConfigInfo;
182 PIO_SCSI_CAPABILITIES PortCapabilities;
183 PSCSI_ADAPTER_BUS_INFO AdapterBusInfo;
184 PSCSI_INQUIRY_DATA UnitInfo;
185 PINQUIRYDATA InquiryData;
186 PCHAR Buffer;
187 ULONG Bus;
188 ULONG DeviceCount;
189 BOOLEAN FoundDevice;
190 NTSTATUS Status;
191
192 DPRINT("DiskClassFindDevices() called.\n");
193
194 /* Get port capabilities */
195 Status = ScsiClassGetCapabilities(PortDeviceObject,
196 &PortCapabilities);
197 if (!NT_SUCCESS(Status))
198 {
199 DPRINT("ScsiClassGetCapabilities() failed! (Status 0x%lX)\n", Status);
200 return(FALSE);
201 }
202
203 DPRINT("MaximumTransferLength: %lu\n", PortCapabilities->MaximumTransferLength);
204
205 /* Get inquiry data */
206 Status = ScsiClassGetInquiryData(PortDeviceObject,
207 (PSCSI_ADAPTER_BUS_INFO *)&Buffer);
208 if (!NT_SUCCESS(Status))
209 {
210 DPRINT("ScsiClassGetInquiryData() failed! (Status %x)\n", Status);
211 return(FALSE);
212 }
213
214 /* Check whether there are unclaimed devices */
215 AdapterBusInfo = (PSCSI_ADAPTER_BUS_INFO)Buffer;
216 DeviceCount = ScsiClassFindUnclaimedDevices(InitializationData,
217 AdapterBusInfo);
218 if (DeviceCount == 0)
219 {
220 DPRINT1("No unclaimed devices!\n");
221 return(FALSE);
222 }
223
224 DPRINT("Found %lu unclaimed devices!\n", DeviceCount);
225
226 ConfigInfo = IoGetConfigurationInformation();
227
228 /* Search each bus of this adapter */
229 for (Bus = 0; Bus < (ULONG)AdapterBusInfo->NumberOfBuses; Bus++)
230 {
231 DPRINT("Searching bus %lu\n", Bus);
232
233 UnitInfo = (PSCSI_INQUIRY_DATA)(Buffer + AdapterBusInfo->BusData[Bus].InquiryDataOffset);
234
235 while (AdapterBusInfo->BusData[Bus].InquiryDataOffset)
236 {
237 InquiryData = (PINQUIRYDATA)UnitInfo->InquiryData;
238
239 if (((InquiryData->DeviceType == DIRECT_ACCESS_DEVICE) ||
240 (InquiryData->DeviceType == OPTICAL_DEVICE)) &&
241 (InquiryData->DeviceTypeQualifier == 0) &&
242 (UnitInfo->DeviceClaimed == FALSE))
243 {
244 DPRINT("Vendor: '%.24s'\n",
245 InquiryData->VendorId);
246
247 /* Create device objects for disk */
248 Status = DiskClassCreateDeviceObject(DriverObject,
249 RegistryPath,
250 PortDeviceObject,
251 PortNumber,
252 ConfigInfo->DiskCount,
253 PortCapabilities,
254 UnitInfo,
255 InitializationData);
256 if (NT_SUCCESS(Status))
257 {
258 ConfigInfo->DiskCount++;
259 FoundDevice = TRUE;
260 }
261 }
262
263 if (UnitInfo->NextInquiryDataOffset == 0)
264 break;
265
266 UnitInfo = (PSCSI_INQUIRY_DATA)(Buffer + UnitInfo->NextInquiryDataOffset);
267 }
268 }
269
270 ExFreePool(Buffer);
271 ExFreePool(PortCapabilities);
272
273 DPRINT("DiskClassFindDevices() done\n");
274
275 return(FoundDevice);
276 }
277
278
279 /**********************************************************************
280 * NAME EXPORTED
281 * DiskClassCheckDevice
282 *
283 * DESCRIPTION
284 * This function checks the InquiryData for the correct device
285 * type and qualifier.
286 *
287 * RUN LEVEL
288 * PASSIVE_LEVEL
289 *
290 * ARGUMENTS
291 * InquiryData
292 * Pointer to the inquiry data for the device in question.
293 *
294 * RETURN VALUE
295 * TRUE: A disk device was found.
296 * FALSE: Otherwise.
297 */
298
299 BOOLEAN STDCALL
300 DiskClassCheckDevice(IN PINQUIRYDATA InquiryData)
301 {
302 return((InquiryData->DeviceType == DIRECT_ACCESS_DEVICE ||
303 InquiryData->DeviceType == OPTICAL_DEVICE) &&
304 InquiryData->DeviceTypeQualifier == 0);
305 }
306
307
308 /**********************************************************************
309 * NAME EXPORTED
310 * DiskClassCheckReadWrite
311 *
312 * DESCRIPTION
313 * This function checks the given IRP for correct data.
314 *
315 * RUN LEVEL
316 * PASSIVE_LEVEL
317 *
318 * ARGUMENTS
319 * DeviceObject
320 * Pointer to the device.
321 *
322 * Irp
323 * Irp to check.
324 *
325 * RETURN VALUE
326 * STATUS_SUCCESS: The IRP matches the requirements of the given device.
327 * Others: Failure.
328 */
329
330 NTSTATUS STDCALL
331 DiskClassCheckReadWrite(IN PDEVICE_OBJECT DeviceObject,
332 IN PIRP Irp)
333 {
334 DPRINT1("DiskClassCheckReadWrite() called\n");
335
336 return(STATUS_SUCCESS);
337 }
338
339
340 // DiskClassCreateDeviceObject
341 //
342 // DESCRIPTION:
343 // Create the raw device and any partition devices on this drive
344 //
345 // RUN LEVEL:
346 // PASSIVE_LEVEL
347 //
348 // ARGUMENTS:
349 // IN PDRIVER_OBJECT DriverObject The system created driver object
350 // IN PCONTROLLER_OBJECT ControllerObject
351 // IN PIDE_CONTROLLER_EXTENSION ControllerExtension
352 // The IDE controller extension for
353 // this device
354 // IN int DriveIdx The index of the drive on this
355 // controller
356 // IN int HarddiskIdx The NT device number for this
357 // drive
358 //
359 // RETURNS:
360 // TRUE Drive exists and devices were created
361 // FALSE no devices were created for this device
362 //
363
364 static NTSTATUS
365 DiskClassCreateDeviceObject(IN PDRIVER_OBJECT DriverObject,
366 IN PUNICODE_STRING RegistryPath, /* what's this used for? */
367 IN PDEVICE_OBJECT PortDeviceObject,
368 IN ULONG PortNumber,
369 IN ULONG DiskNumber,
370 IN PIO_SCSI_CAPABILITIES Capabilities,
371 IN PSCSI_INQUIRY_DATA InquiryData,
372 IN PCLASS_INIT_DATA InitializationData)
373 {
374 OBJECT_ATTRIBUTES ObjectAttributes;
375 UNICODE_STRING UnicodeDeviceDirName;
376 WCHAR NameBuffer[80];
377 CHAR NameBuffer2[80];
378 PDEVICE_OBJECT DiskDeviceObject;
379 PDEVICE_OBJECT PartitionDeviceObject;
380 PDEVICE_EXTENSION DiskDeviceExtension; /* defined in class2.h */
381 PDEVICE_EXTENSION PartitionDeviceExtension; /* defined in class2.h */
382 PDRIVE_LAYOUT_INFORMATION PartitionList = NULL;
383 HANDLE Handle;
384 PPARTITION_INFORMATION PartitionEntry;
385 PDISK_DATA DiskData;
386 ULONG PartitionNumber;
387 NTSTATUS Status;
388
389 DPRINT("DiskClassCreateDeviceObject() called\n");
390
391 /* Create the harddisk device directory */
392 swprintf(NameBuffer,
393 L"\\Device\\Harddisk%lu",
394 DiskNumber);
395 RtlInitUnicodeString(&UnicodeDeviceDirName,
396 NameBuffer);
397 InitializeObjectAttributes(&ObjectAttributes,
398 &UnicodeDeviceDirName,
399 0,
400 NULL,
401 NULL);
402 Status = ZwCreateDirectoryObject(&Handle,
403 0,
404 &ObjectAttributes);
405 if (!NT_SUCCESS(Status))
406 {
407 DbgPrint("Could not create device dir object\n");
408 return(Status);
409 }
410
411 /* Claim the disk device */
412 Status = ScsiClassClaimDevice(PortDeviceObject,
413 InquiryData,
414 FALSE,
415 &PortDeviceObject);
416 if (!NT_SUCCESS(Status))
417 {
418 DbgPrint("Could not claim disk device\n");
419
420 ZwMakeTemporaryObject(Handle);
421 ZwClose(Handle);
422
423 return(Status);
424 }
425
426 /* Create disk device (Partition 0) */
427 sprintf(NameBuffer2,
428 "\\Device\\Harddisk%lu\\Partition0",
429 DiskNumber);
430
431 Status = ScsiClassCreateDeviceObject(DriverObject,
432 NameBuffer2,
433 NULL,
434 &DiskDeviceObject,
435 InitializationData);
436 if (!NT_SUCCESS(Status))
437 {
438 DPRINT1("ScsiClassCreateDeviceObject() failed (Status %x)\n", Status);
439
440 /* Release (unclaim) the disk */
441 ScsiClassClaimDevice(PortDeviceObject,
442 InquiryData,
443 TRUE,
444 NULL);
445
446 /* Delete the harddisk device directory */
447 ZwMakeTemporaryObject(Handle);
448 ZwClose(Handle);
449
450 return(Status);
451 }
452
453 DiskDeviceObject->Flags |= DO_DIRECT_IO;
454 if (((PINQUIRYDATA)InquiryData->InquiryData)->RemovableMedia)
455 {
456 DiskDeviceObject->Characteristics |= FILE_REMOVABLE_MEDIA;
457 }
458 DiskDeviceObject->StackSize = (CCHAR)PortDeviceObject->StackSize + 1;
459
460 if (PortDeviceObject->AlignmentRequirement > DiskDeviceObject->AlignmentRequirement)
461 {
462 DiskDeviceObject->AlignmentRequirement = PortDeviceObject->AlignmentRequirement;
463 }
464
465 DiskDeviceExtension = DiskDeviceObject->DeviceExtension;
466 DiskDeviceExtension->LockCount = 0;
467 DiskDeviceExtension->DeviceNumber = DiskNumber;
468 DiskDeviceExtension->PortDeviceObject = PortDeviceObject;
469 DiskDeviceExtension->PhysicalDevice = DiskDeviceObject;
470
471 /* FIXME: Not yet! Will cause pointer corruption! */
472 // DiskDeviceExtension->PortCapabilities = PortCapabilities;
473
474 DiskDeviceExtension->StartingOffset.QuadPart = 0;
475 DiskDeviceExtension->PortNumber = (UCHAR)PortNumber;
476 DiskDeviceExtension->PathId = InquiryData->PathId;
477 DiskDeviceExtension->TargetId = InquiryData->TargetId;
478 DiskDeviceExtension->Lun = InquiryData->Lun;
479
480 /* zero-out disk data */
481 DiskData = (PDISK_DATA)(DiskDeviceExtension + 1);
482 RtlZeroMemory(DiskData,
483 sizeof(DISK_DATA));
484
485 /* Get disk geometry */
486 DiskDeviceExtension->DiskGeometry = ExAllocatePool(NonPagedPool,
487 sizeof(DISK_GEOMETRY));
488 if (DiskDeviceExtension->DiskGeometry == NULL)
489 {
490 DPRINT1("Failed to allocate geometry buffer!\n");
491
492 IoDeleteDevice(DiskDeviceObject);
493
494 /* Release (unclaim) the disk */
495 ScsiClassClaimDevice(PortDeviceObject,
496 InquiryData,
497 TRUE,
498 NULL);
499
500 /* Delete the harddisk device directory */
501 ZwMakeTemporaryObject(Handle);
502 ZwClose(Handle);
503
504 return(STATUS_INSUFFICIENT_RESOURCES);
505 }
506
507 /* Read the drive's capacity */
508 Status = ScsiClassReadDriveCapacity(DiskDeviceObject);
509 if (!NT_SUCCESS(Status) &&
510 (DiskDeviceObject->Characteristics & FILE_REMOVABLE_MEDIA) == 0)
511 {
512 DPRINT1("Failed to retrieve drive capacity!\n");
513 return(STATUS_SUCCESS);
514 }
515 else
516 {
517 /* Clear the verify flag for removable media drives. */
518 DiskDeviceObject->Flags &= ~DO_VERIFY_VOLUME;
519 }
520
521 DPRINT("SectorSize: %lu\n", DiskDeviceExtension->DiskGeometry->BytesPerSector);
522
523 /* Read partition table */
524 Status = IoReadPartitionTable(DiskDeviceObject,
525 DiskDeviceExtension->DiskGeometry->BytesPerSector,
526 TRUE,
527 &PartitionList);
528
529 DPRINT("IoReadPartitionTable(): Status: %lx\n", Status);
530
531 if ((!NT_SUCCESS(Status) || PartitionList->PartitionCount == 0) &&
532 DiskDeviceObject->Characteristics & FILE_REMOVABLE_MEDIA)
533 {
534 if (!NT_SUCCESS(Status))
535 {
536 /* Drive is not ready. */
537 DPRINT1("Drive not ready\n");
538 DiskData->DriveNotReady = TRUE;
539 }
540 else
541 {
542 ExFreePool(PartitionList);
543 }
544
545 /* Allocate a partition list for a single entry. */
546 PartitionList = ExAllocatePool(NonPagedPool,
547 sizeof(DRIVE_LAYOUT_INFORMATION));
548 if (PartitionList != NULL)
549 {
550 RtlZeroMemory(PartitionList,
551 sizeof(DRIVE_LAYOUT_INFORMATION));
552 PartitionList->PartitionCount = 1;
553
554 Status = STATUS_SUCCESS;
555 }
556 }
557
558 if (NT_SUCCESS(Status))
559 {
560 DPRINT("Read partition table!\n");
561
562 DPRINT(" Number of partitions: %u\n", PartitionList->PartitionCount);
563
564 for (PartitionNumber = 0; PartitionNumber < PartitionList->PartitionCount; PartitionNumber++)
565 {
566 PartitionEntry = &PartitionList->PartitionEntry[PartitionNumber];
567
568 DPRINT("Partition %02ld: nr: %d boot: %1x type: %x offset: %I64d size: %I64d\n",
569 PartitionNumber,
570 PartitionEntry->PartitionNumber,
571 PartitionEntry->BootIndicator,
572 PartitionEntry->PartitionType,
573 PartitionEntry->StartingOffset.QuadPart / 512 /*DrvParms.BytesPerSector*/,
574 PartitionEntry->PartitionLength.QuadPart / 512 /* DrvParms.BytesPerSector*/);
575
576 /* Create partition device object */
577 sprintf(NameBuffer2,
578 "\\Device\\Harddisk%lu\\Partition%lu",
579 DiskNumber,
580 PartitionNumber + 1);
581
582 Status = ScsiClassCreateDeviceObject(DriverObject,
583 NameBuffer2,
584 DiskDeviceObject,
585 &PartitionDeviceObject,
586 InitializationData);
587 DPRINT("ScsiClassCreateDeviceObject(): Status %x\n", Status);
588 if (NT_SUCCESS(Status))
589 {
590 PartitionDeviceObject->Flags = DiskDeviceObject->Flags;
591 PartitionDeviceObject->Characteristics = DiskDeviceObject->Characteristics;
592 PartitionDeviceObject->StackSize = DiskDeviceObject->StackSize;
593 PartitionDeviceObject->AlignmentRequirement = DiskDeviceObject->AlignmentRequirement;
594
595 PartitionDeviceExtension = PartitionDeviceObject->DeviceExtension;
596 PartitionDeviceExtension->LockCount = 0;
597 PartitionDeviceExtension->DeviceNumber = DiskNumber;
598 PartitionDeviceExtension->PortDeviceObject = PortDeviceObject;
599 PartitionDeviceExtension->DiskGeometry = DiskDeviceExtension->DiskGeometry;
600 PartitionDeviceExtension->PhysicalDevice = DiskDeviceExtension->PhysicalDevice;
601
602 /* FIXME: Not yet! Will cause pointer corruption! */
603 // PartitionDeviceExtension->PortCapabilities = PortCapabilities;
604
605 PartitionDeviceExtension->StartingOffset.QuadPart =
606 PartitionEntry->StartingOffset.QuadPart;
607 PartitionDeviceExtension->PartitionLength.QuadPart =
608 PartitionEntry->PartitionLength.QuadPart;
609 PartitionDeviceExtension->PortNumber = (UCHAR)PortNumber;
610 PartitionDeviceExtension->PathId = InquiryData->PathId;
611 PartitionDeviceExtension->TargetId = InquiryData->TargetId;
612 PartitionDeviceExtension->Lun = InquiryData->Lun;
613 PartitionDeviceExtension->SectorShift = DiskDeviceExtension->SectorShift;
614
615 DiskData = (PDISK_DATA)(PartitionDeviceExtension + 1);
616 DiskData->PartitionType = PartitionEntry->PartitionType;
617 DiskData->PartitionNumber = PartitionNumber + 1;
618 DiskData->HiddenSectors = PartitionEntry->HiddenSectors;
619 DiskData->BootIndicator = PartitionEntry->BootIndicator;
620 DiskData->DriveNotReady = FALSE;
621 }
622 else
623 {
624 DPRINT1("ScsiClassCreateDeviceObject() failed to create partition device object (Status %x)\n", Status);
625
626 break;
627 }
628 }
629
630
631 }
632
633 if (PartitionList != NULL)
634 ExFreePool(PartitionList);
635
636 DPRINT("DiskClassCreateDeviceObjects() done\n");
637
638 return(STATUS_SUCCESS);
639 }
640
641
642
643
644
645 // DiskClassDeviceControl
646 //
647 // DESCRIPTION:
648 // Answer requests for device control calls
649 //
650 // RUN LEVEL:
651 // PASSIVE_LEVEL
652 //
653 // ARGUMENTS:
654 // Standard dispatch arguments
655 //
656 // RETURNS:
657 // NTSTATUS
658 //
659
660 NTSTATUS STDCALL
661 DiskClassDeviceControl(IN PDEVICE_OBJECT DeviceObject,
662 IN PIRP Irp)
663 {
664 PDEVICE_EXTENSION DeviceExtension;
665 PIO_STACK_LOCATION IrpStack;
666 ULONG ControlCode, InputLength, OutputLength;
667 PDISK_DATA DiskData;
668 ULONG Information;
669 NTSTATUS Status;
670
671 DPRINT("DiskClassDeviceControl() called!\n");
672
673 Status = STATUS_INVALID_DEVICE_REQUEST;
674 Information = 0;
675 IrpStack = IoGetCurrentIrpStackLocation(Irp);
676 ControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;
677 InputLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;
678 OutputLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;
679 DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
680 DiskData = (PDISK_DATA)(DeviceExtension + 1);
681
682 /* A huge switch statement in a Windows program?! who would have thought? */
683 switch (ControlCode)
684 {
685 case IOCTL_DISK_GET_DRIVE_GEOMETRY:
686 DPRINT("IOCTL_DISK_GET_DRIVE_GEOMETRY\n");
687 if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DISK_GEOMETRY))
688 {
689 Status = STATUS_INVALID_PARAMETER;
690 }
691 else if (DeviceExtension->DiskGeometry == NULL)
692 {
693 DPRINT1("No disk geometry available!\n");
694 Status = STATUS_NO_SUCH_DEVICE;
695 }
696 else
697 {
698 PDISK_GEOMETRY Geometry;
699
700 Geometry = (PDISK_GEOMETRY) Irp->AssociatedIrp.SystemBuffer;
701 RtlMoveMemory(Geometry,
702 DeviceExtension->DiskGeometry,
703 sizeof(DISK_GEOMETRY));
704
705 Status = STATUS_SUCCESS;
706 Information = sizeof(DISK_GEOMETRY);
707 }
708 break;
709
710 case IOCTL_DISK_GET_PARTITION_INFO:
711 DPRINT("IOCTL_DISK_GET_PARTITION_INFO\n");
712 if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength <
713 sizeof(PARTITION_INFORMATION))
714 {
715 Status = STATUS_INFO_LENGTH_MISMATCH;
716 }
717 else if (DiskData->PartitionNumber == 0)
718 {
719 Status = STATUS_INVALID_DEVICE_REQUEST;
720 }
721 else
722 {
723 PPARTITION_INFORMATION PartitionInfo;
724
725 PartitionInfo = (PPARTITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
726
727 PartitionInfo->PartitionType = DiskData->PartitionType;
728 PartitionInfo->StartingOffset = DeviceExtension->StartingOffset;
729 PartitionInfo->PartitionLength = DeviceExtension->PartitionLength;
730 PartitionInfo->HiddenSectors = DiskData->HiddenSectors;
731 PartitionInfo->PartitionNumber = DiskData->PartitionNumber;
732 PartitionInfo->BootIndicator = DiskData->BootIndicator;
733 PartitionInfo->RewritePartition = FALSE;
734 PartitionInfo->RecognizedPartition =
735 IsRecognizedPartition(DiskData->PartitionType);
736
737 Status = STATUS_SUCCESS;
738 Information = sizeof(PARTITION_INFORMATION);
739 }
740 break;
741
742 case IOCTL_DISK_SET_PARTITION_INFO:
743 DPRINT1("Unhandled IOCTL_DISK_SET_PARTITION_INFO\n");
744 Status = STATUS_INVALID_DEVICE_REQUEST;
745 Information = 0;
746 break;
747
748 case IOCTL_DISK_GET_DRIVE_LAYOUT:
749 if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength <
750 sizeof(DRIVE_LAYOUT_INFORMATION))
751 {
752 Status = STATUS_BUFFER_TOO_SMALL;
753 }
754 else
755 {
756 PDRIVE_LAYOUT_INFORMATION PartitionList;
757
758 Status = IoReadPartitionTable(DeviceExtension->PhysicalDevice,
759 DeviceExtension->DiskGeometry->BytesPerSector,
760 FALSE,
761 &PartitionList);
762 if (NT_SUCCESS(Status))
763 {
764 ULONG BufferSize;
765
766 BufferSize = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION,
767 PartitionEntry[0]);
768 BufferSize += PartitionList->PartitionCount * sizeof(PARTITION_INFORMATION);
769
770 if (BufferSize > IrpStack->Parameters.DeviceIoControl.OutputBufferLength)
771 {
772 Status = STATUS_BUFFER_TOO_SMALL;
773 }
774 else
775 {
776 RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer,
777 PartitionList,
778 BufferSize);
779 Status = STATUS_SUCCESS;
780 Information = BufferSize;
781 }
782 ExFreePool(PartitionList);
783 }
784 }
785 break;
786
787 case IOCTL_DISK_SET_DRIVE_LAYOUT:
788 case IOCTL_DISK_VERIFY:
789 case IOCTL_DISK_FORMAT_TRACKS:
790 case IOCTL_DISK_PERFORMANCE:
791 case IOCTL_DISK_IS_WRITABLE:
792 case IOCTL_DISK_LOGGING:
793 case IOCTL_DISK_FORMAT_TRACKS_EX:
794 case IOCTL_DISK_HISTOGRAM_STRUCTURE:
795 case IOCTL_DISK_HISTOGRAM_DATA:
796 case IOCTL_DISK_HISTOGRAM_RESET:
797 case IOCTL_DISK_REQUEST_STRUCTURE:
798 case IOCTL_DISK_REQUEST_DATA:
799
800 /* If we get here, something went wrong. inform the requestor */
801 default:
802 DPRINT1("Unhandled control code: %lx\n", ControlCode);
803 Status = STATUS_INVALID_DEVICE_REQUEST;
804 Information = 0;
805 break;
806 }
807
808 Irp->IoStatus.Status = Status;
809 Irp->IoStatus.Information = Information;
810 IoCompleteRequest(Irp,
811 IO_NO_INCREMENT);
812
813 return(Status);
814 }
815
816
817 /**********************************************************************
818 * NAME EXPORTED
819 * DiskClassShutdownFlush
820 *
821 * DESCRIPTION
822 * Answer requests for shutdown and flush calls.
823 *
824 * RUN LEVEL
825 * PASSIVE_LEVEL
826 *
827 * ARGUMENTS
828 * DeviceObject
829 * Pointer to the device.
830 *
831 * Irp
832 * Pointer to the IRP
833 *
834 * RETURN VALUE
835 * Status
836 */
837
838 NTSTATUS STDCALL
839 DiskClassShutdownFlush(IN PDEVICE_OBJECT DeviceObject,
840 IN PIRP Irp)
841 {
842 DPRINT("DiskClassShutdownFlush() called!\n");
843
844 Irp->IoStatus.Status = STATUS_SUCCESS;
845 Irp->IoStatus.Information = 0;
846 IoCompleteRequest(Irp, IO_NO_INCREMENT);
847
848 return(STATUS_SUCCESS);
849 }
850
851
852 /* EOF */