reactos/drivers/filesystems/ntfs/fsctl.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 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., 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/filesystems/ntfs/fsctl.c
  22  * PURPOSE:          NTFS filesystem driver
  23  * PROGRAMMER:       Eric Kohl
  24  *                   Valentin Verkhovsky
  25  *                   Pierre Schweitzer
  26  */
  27
  28 /* INCLUDES *****************************************************************/
  29
  30 #include "ntfs.h"
  31
  32 #include <ntdddisk.h>
  33
  34 #define NDEBUG
  35 #include <debug.h>
  36
  37 /* FUNCTIONS ****************************************************************/
  38
  39 /*
  40  * FUNCTION: Tests if the device contains a filesystem that can be mounted
  41  *           by this fsd.
  42  */
  43 static
  44 NTSTATUS
  45 NtfsHasFileSystem(PDEVICE_OBJECT DeviceToMount)
  46 {
  47     PARTITION_INFORMATION PartitionInfo;
  48     DISK_GEOMETRY DiskGeometry;
  49     ULONG ClusterSize, Size, k;
  50     PBOOT_SECTOR BootSector;
  51     NTSTATUS Status;
  52
  53     DPRINT1("NtfsHasFileSystem() called\n");
  54
  55     Size = sizeof(DISK_GEOMETRY);
  56     Status = NtfsDeviceIoControl(DeviceToMount,
  57                                  IOCTL_DISK_GET_DRIVE_GEOMETRY,
  58                                  NULL,
  59                                  0,
  60                                  &DiskGeometry,
  61                                  &Size,
  62                                  TRUE);
  63     if (!NT_SUCCESS(Status))
  64     {
  65         DPRINT1("NtfsDeviceIoControl() failed (Status %lx)\n", Status);
  66         return Status;
  67     }
  68
  69     if (DiskGeometry.MediaType == FixedMedia)
  70     {
  71         /* We have found a hard disk */
  72         Size = sizeof(PARTITION_INFORMATION);
  73         Status = NtfsDeviceIoControl(DeviceToMount,
  74                                      IOCTL_DISK_GET_PARTITION_INFO,
  75                                      NULL,
  76                                      0,
  77                                      &PartitionInfo,
  78                                      &Size,
  79                                      TRUE);
  80         if (!NT_SUCCESS(Status))
  81         {
  82             DPRINT1("NtfsDeviceIoControl() failed (Status %lx)\n", Status);
  83             return Status;
  84         }
  85
  86         if (PartitionInfo.PartitionType != PARTITION_IFS)
  87         {
  88             DPRINT1("Invalid partition type\n");
  89             return STATUS_UNRECOGNIZED_VOLUME;
  90         }
  91     }
  92
  93     DPRINT1("BytesPerSector: %lu\n", DiskGeometry.BytesPerSector);
  94     BootSector = ExAllocatePoolWithTag(NonPagedPool,
  95                                        DiskGeometry.BytesPerSector,
  96                                        TAG_NTFS);
  97     if (BootSector == NULL)
  98     {
  99         return STATUS_INSUFFICIENT_RESOURCES;
 100     }
 101
 102     Status = NtfsReadSectors(DeviceToMount,
 103                              0,
 104                              1,
 105                              DiskGeometry.BytesPerSector,
 106                              (PVOID)BootSector,
 107                              TRUE);
 108     if (!NT_SUCCESS(Status))
 109     {
 110         goto ByeBye;
 111     }
 112
 113     /*
 114      * Check values of different fields. If those fields have not expected
 115      * values, we fail, to avoid mounting partitions that Windows won't mount.
 116      */
 117
 118     /* OEMID: this field must be NTFS */
 119     if (RtlCompareMemory(BootSector->OEMID, "NTFS    ", 8) != 8)
 120     {
 121         DPRINT1("Failed with NTFS-identifier: [%.8s]\n", BootSector->OEMID);
 122         Status = STATUS_UNRECOGNIZED_VOLUME;
 123         goto ByeBye;
 124     }
 125
 126     /* Unused0: this field must be COMPLETELY null */
 127     for (k = 0; k < 7; k++)
 128     {
 129         if (BootSector->BPB.Unused0[k] != 0)
 130         {
 131             DPRINT1("Failed in field Unused0: [%.7s]\n", BootSector->BPB.Unused0);
 132             Status = STATUS_UNRECOGNIZED_VOLUME;
 133             goto ByeBye;
 134         }
 135     }
 136
 137     /* Unused3: this field must be COMPLETELY null */
 138     for (k = 0; k < 4; k++)
 139     {
 140         if (BootSector->BPB.Unused3[k] != 0)
 141         {
 142             DPRINT1("Failed in field Unused3: [%.4s]\n", BootSector->BPB.Unused3);
 143             Status = STATUS_UNRECOGNIZED_VOLUME;
 144             goto ByeBye;
 145         }
 146     }
 147
 148     /* Check cluster size */
 149     ClusterSize = BootSector->BPB.BytesPerSector * BootSector->BPB.SectorsPerCluster;
 150     if (ClusterSize != 512 && ClusterSize != 1024 &&
 151         ClusterSize != 2048 && ClusterSize != 4096 &&
 152         ClusterSize != 8192 && ClusterSize != 16384 &&
 153         ClusterSize != 32768 && ClusterSize != 65536)
 154     {
 155         DPRINT1("Cluster size failed: %hu, %hu, %hu\n",
 156                 BootSector->BPB.BytesPerSector,
 157                 BootSector->BPB.SectorsPerCluster,
 158                 ClusterSize);
 159         Status = STATUS_UNRECOGNIZED_VOLUME;
 160         goto ByeBye;
 161     }
 162
 163 ByeBye:
 164     ExFreePool(BootSector);
 165
 166     return Status;
 167 }
 168
 169
 170 static
 171 NTSTATUS
 172 NtfsGetVolumeData(PDEVICE_OBJECT DeviceObject,
 173                   PDEVICE_EXTENSION DeviceExt)
 174 {
 175     DISK_GEOMETRY DiskGeometry;
 176     PFILE_RECORD_HEADER MftRecord;
 177     PFILE_RECORD_HEADER VolumeRecord;
 178     PVOLINFO_ATTRIBUTE VolumeInfo;
 179     PBOOT_SECTOR BootSector;
 180     PATTRIBUTE Attribute;
 181     ULONG Size;
 182     PNTFS_INFO NtfsInfo = &DeviceExt->NtfsInfo;
 183     NTSTATUS Status;
 184     PNTFS_FCB VolumeFcb;
 185     PWSTR VolumeNameU;
 186
 187     DPRINT("NtfsGetVolumeData() called\n");
 188
 189     Size = sizeof(DISK_GEOMETRY);
 190     Status = NtfsDeviceIoControl(DeviceObject,
 191                                  IOCTL_DISK_GET_DRIVE_GEOMETRY,
 192                                  NULL,
 193                                  0,
 194                                  &DiskGeometry,
 195                                  &Size,
 196                                  TRUE);
 197     if (!NT_SUCCESS(Status))
 198     {
 199         DPRINT("NtfsDeviceIoControl() failed (Status %lx)\n", Status);
 200         return Status;
 201     }
 202
 203     DPRINT("BytesPerSector: %lu\n", DiskGeometry.BytesPerSector);
 204     BootSector = ExAllocatePoolWithTag(NonPagedPool,
 205                                        DiskGeometry.BytesPerSector,
 206                                        TAG_NTFS);
 207     if (BootSector == NULL)
 208     {
 209         return STATUS_INSUFFICIENT_RESOURCES;
 210     }
 211
 212     Status = NtfsReadSectors(DeviceObject,
 213                              0, /* Partition boot sector */
 214                              1,
 215                              DiskGeometry.BytesPerSector,
 216                              (PVOID)BootSector,
 217                              TRUE);
 218     if (!NT_SUCCESS(Status))
 219     {
 220         ExFreePool(BootSector);
 221         return Status;
 222     }
 223
 224     /* Read data from the bootsector */
 225     NtfsInfo->BytesPerSector = BootSector->BPB.BytesPerSector;
 226     NtfsInfo->SectorsPerCluster = BootSector->BPB.SectorsPerCluster;
 227     NtfsInfo->BytesPerCluster = BootSector->BPB.BytesPerSector * BootSector->BPB.SectorsPerCluster;
 228     NtfsInfo->SectorCount = BootSector->EBPB.SectorCount;
 229
 230     NtfsInfo->MftStart.QuadPart = BootSector->EBPB.MftLocation;
 231     NtfsInfo->MftMirrStart.QuadPart = BootSector->EBPB.MftMirrLocation;
 232     NtfsInfo->SerialNumber = BootSector->EBPB.SerialNumber;
 233     if (BootSector->EBPB.ClustersPerMftRecord > 0)
 234         NtfsInfo->BytesPerFileRecord = BootSector->EBPB.ClustersPerMftRecord * NtfsInfo->BytesPerCluster;
 235     else
 236         NtfsInfo->BytesPerFileRecord = 1 << (-BootSector->EBPB.ClustersPerMftRecord);
 237     if (BootSector->EBPB.ClustersPerIndexRecord > 0)
 238         NtfsInfo->BytesPerIndexRecord = BootSector->EBPB.ClustersPerIndexRecord * NtfsInfo->BytesPerCluster;
 239     else
 240         NtfsInfo->BytesPerIndexRecord = 1 << (-BootSector->EBPB.ClustersPerIndexRecord);
 241
 242     DPRINT("Boot sector information:\n");
 243     DPRINT("  BytesPerSector:         %hu\n", BootSector->BPB.BytesPerSector);
 244     DPRINT("  SectorsPerCluster:      %hu\n", BootSector->BPB.SectorsPerCluster);
 245     DPRINT("  SectorCount:            %I64u\n", BootSector->EBPB.SectorCount);
 246     DPRINT("  MftStart:               %I64u\n", BootSector->EBPB.MftLocation);
 247     DPRINT("  MftMirrStart:           %I64u\n", BootSector->EBPB.MftMirrLocation);
 248     DPRINT("  ClustersPerMftRecord:   %lx\n", BootSector->EBPB.ClustersPerMftRecord);
 249     DPRINT("  ClustersPerIndexRecord: %lx\n", BootSector->EBPB.ClustersPerIndexRecord);
 250     DPRINT("  SerialNumber:           %I64x\n", BootSector->EBPB.SerialNumber);
 251
 252     ExFreePool(BootSector);
 253
 254     MftRecord = ExAllocatePoolWithTag(NonPagedPool,
 255                                       NtfsInfo->BytesPerFileRecord,
 256                                       TAG_NTFS);
 257     if (MftRecord == NULL)
 258     {
 259         return STATUS_INSUFFICIENT_RESOURCES;
 260     }
 261
 262     Status = NtfsReadSectors(DeviceObject,
 263                              NtfsInfo->MftStart.u.LowPart * NtfsInfo->SectorsPerCluster,
 264                              NtfsInfo->BytesPerFileRecord / NtfsInfo->BytesPerSector,
 265                              NtfsInfo->BytesPerSector,
 266                              (PVOID)MftRecord,
 267                              TRUE);
 268     if (!NT_SUCCESS(Status))
 269     {
 270         ExFreePool(MftRecord);
 271         return Status;
 272     }
 273
 274     VolumeRecord = ExAllocatePoolWithTag(NonPagedPool,
 275                                          NtfsInfo->BytesPerFileRecord,
 276                                          TAG_NTFS);
 277     if (VolumeRecord == NULL)
 278     {
 279         ExFreePool(MftRecord);
 280         return STATUS_INSUFFICIENT_RESOURCES;
 281     }
 282
 283     /* Read Volume File (MFT index 3) */
 284     DeviceExt->StorageDevice = DeviceObject;
 285     Status = ReadFileRecord(DeviceExt,
 286                             3,
 287                             VolumeRecord,
 288                             MftRecord);
 289     if (!NT_SUCCESS(Status))
 290     {
 291         ExFreePool(VolumeRecord);
 292         ExFreePool(MftRecord);
 293         return Status;
 294     }
 295
 296     /* Enumerate attributes */
 297     NtfsDumpFileAttributes (MftRecord);
 298
 299     /* Enumerate attributes */
 300     NtfsDumpFileAttributes (VolumeRecord);
 301
 302     /* Get volume name */
 303     Attribute = FindAttribute (VolumeRecord, AttributeVolumeName, NULL);
 304     DPRINT("Attribute %p\n", Attribute);
 305
 306     if (Attribute != NULL && ((PRESIDENT_ATTRIBUTE)Attribute)->ValueLength != 0)
 307     {
 308         DPRINT("Data length %lu\n", AttributeDataLength (Attribute));
 309         NtfsInfo->VolumeLabelLength =
 310            min (((PRESIDENT_ATTRIBUTE)Attribute)->ValueLength, MAXIMUM_VOLUME_LABEL_LENGTH);
 311         RtlCopyMemory(NtfsInfo->VolumeLabel,
 312                       (PVOID)((ULONG_PTR)Attribute + ((PRESIDENT_ATTRIBUTE)Attribute)->ValueOffset),
 313                       NtfsInfo->VolumeLabelLength);
 314         VolumeNameU = NtfsInfo->VolumeLabel;
 315     }
 316     else
 317     {
 318         NtfsInfo->VolumeLabelLength = 0;
 319         VolumeNameU = L"\0";
 320     }
 321
 322     VolumeFcb = NtfsCreateFCB(VolumeNameU, DeviceExt);
 323     if (VolumeFcb == NULL)
 324     {
 325         ExFreePool(VolumeRecord);
 326         ExFreePool(MftRecord);
 327         return STATUS_INSUFFICIENT_RESOURCES;
 328     }
 329
 330     VolumeFcb->Flags = FCB_IS_VOLUME;
 331     VolumeFcb->RFCB.FileSize.QuadPart = DeviceExt->NtfsInfo.SectorCount * DeviceExt->NtfsInfo.BytesPerSector;
 332     VolumeFcb->RFCB.ValidDataLength = VolumeFcb->RFCB.FileSize;
 333     VolumeFcb->RFCB.AllocationSize = VolumeFcb->RFCB.FileSize;
 334     DeviceExt->VolumeFcb = VolumeFcb;
 335
 336     /* Get volume information */
 337     Attribute = FindAttribute (VolumeRecord, AttributeVolumeInformation, NULL);
 338     DPRINT("Attribute %p\n", Attribute);
 339
 340     if (Attribute != NULL && ((PRESIDENT_ATTRIBUTE)Attribute)->ValueLength != 0)
 341     {
 342         DPRINT("Data length %lu\n", AttributeDataLength (Attribute));
 343         VolumeInfo = (PVOID)((ULONG_PTR)Attribute + ((PRESIDENT_ATTRIBUTE)Attribute)->ValueOffset);
 344
 345         NtfsInfo->MajorVersion = VolumeInfo->MajorVersion;
 346         NtfsInfo->MinorVersion = VolumeInfo->MinorVersion;
 347         NtfsInfo->Flags = VolumeInfo->Flags;
 348     }
 349
 350     ExFreePool(MftRecord);
 351     ExFreePool(VolumeRecord);
 352
 353     return Status;
 354 }
 355
 356
 357 static
 358 NTSTATUS
 359 NtfsMountVolume(PDEVICE_OBJECT DeviceObject,
 360                 PIRP Irp)
 361 {
 362     PDEVICE_OBJECT NewDeviceObject = NULL;
 363     PDEVICE_OBJECT DeviceToMount;
 364     PIO_STACK_LOCATION Stack;
 365     PNTFS_FCB Fcb = NULL;
 366     PNTFS_CCB Ccb = NULL;
 367     PNTFS_VCB Vcb = NULL;
 368     NTSTATUS Status;
 369
 370     DPRINT1("NtfsMountVolume() called\n");
 371
 372     if (DeviceObject != NtfsGlobalData->DeviceObject)
 373     {
 374         Status = STATUS_INVALID_DEVICE_REQUEST;
 375         goto ByeBye;
 376     }
 377
 378     Stack = IoGetCurrentIrpStackLocation(Irp);
 379     DeviceToMount = Stack->Parameters.MountVolume.DeviceObject;
 380
 381     Status = NtfsHasFileSystem(DeviceToMount);
 382     if (!NT_SUCCESS(Status))
 383     {
 384         goto ByeBye;
 385     }
 386
 387     Status = IoCreateDevice(NtfsGlobalData->DriverObject,
 388                             sizeof(DEVICE_EXTENSION),
 389                             NULL,
 390                             FILE_DEVICE_DISK_FILE_SYSTEM,
 391                             0,
 392                             FALSE,
 393                             &NewDeviceObject);
 394     if (!NT_SUCCESS(Status))
 395         goto ByeBye;
 396
 397     NewDeviceObject->Flags |= DO_DIRECT_IO;
 398     Vcb = (PVOID)NewDeviceObject->DeviceExtension;
 399     RtlZeroMemory(Vcb, sizeof(NTFS_VCB));
 400
 401     Vcb->Identifier.Type = NTFS_TYPE_VCB;
 402     Vcb->Identifier.Size = sizeof(NTFS_TYPE_VCB);
 403
 404     Status = NtfsGetVolumeData(DeviceToMount,
 405                                Vcb);
 406     if (!NT_SUCCESS(Status))
 407         goto ByeBye;
 408
 409     NewDeviceObject->Vpb = DeviceToMount->Vpb;
 410
 411     Vcb->StorageDevice = DeviceToMount;
 412     Vcb->StorageDevice->Vpb->DeviceObject = NewDeviceObject;
 413     Vcb->StorageDevice->Vpb->RealDevice = Vcb->StorageDevice;
 414     Vcb->StorageDevice->Vpb->Flags |= VPB_MOUNTED;
 415     NewDeviceObject->StackSize = Vcb->StorageDevice->StackSize + 1;
 416     NewDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 417
 418     Vcb->StreamFileObject = IoCreateStreamFileObject(NULL,
 419                                                      Vcb->StorageDevice);
 420
 421     InitializeListHead(&Vcb->FcbListHead);
 422
 423     Fcb = NtfsCreateFCB(NULL, Vcb);
 424     if (Fcb == NULL)
 425     {
 426         Status = STATUS_INSUFFICIENT_RESOURCES;
 427         goto ByeBye;
 428     }
 429
 430     Ccb = ExAllocatePoolWithTag(NonPagedPool,
 431                                 sizeof(NTFS_CCB),
 432                                 TAG_CCB);
 433     if (Ccb == NULL)
 434     {
 435         Status =  STATUS_INSUFFICIENT_RESOURCES;
 436         goto ByeBye;
 437     }
 438
 439     RtlZeroMemory(Ccb, sizeof(NTFS_CCB));
 440
 441     Ccb->Identifier.Type = NTFS_TYPE_CCB;
 442     Ccb->Identifier.Size = sizeof(NTFS_TYPE_CCB);
 443
 444     Vcb->StreamFileObject->FsContext = Fcb;
 445     Vcb->StreamFileObject->FsContext2 = Ccb;
 446     Vcb->StreamFileObject->SectionObjectPointer = &Fcb->SectionObjectPointers;
 447     Vcb->StreamFileObject->PrivateCacheMap = NULL;
 448     Vcb->StreamFileObject->Vpb = Vcb->Vpb;
 449     Ccb->PtrFileObject = Vcb->StreamFileObject;
 450     Fcb->FileObject = Vcb->StreamFileObject;
 451     Fcb->Vcb = (PDEVICE_EXTENSION)Vcb->StorageDevice;
 452
 453     Fcb->Flags = FCB_IS_VOLUME_STREAM;
 454
 455     Fcb->RFCB.FileSize.QuadPart = Vcb->NtfsInfo.SectorCount * Vcb->NtfsInfo.BytesPerSector;
 456     Fcb->RFCB.ValidDataLength.QuadPart = Vcb->NtfsInfo.SectorCount * Vcb->NtfsInfo.BytesPerSector;
 457     Fcb->RFCB.AllocationSize.QuadPart = Vcb->NtfsInfo.SectorCount * Vcb->NtfsInfo.BytesPerSector; /* Correct? */
 458
 459 //    Fcb->Entry.ExtentLocationL = 0;
 460 //    Fcb->Entry.DataLengthL = DeviceExt->CdInfo.VolumeSpaceSize * BLOCKSIZE;
 461
 462     CcInitializeCacheMap(Vcb->StreamFileObject,
 463                          (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
 464                          FALSE,
 465                          &(NtfsGlobalData->CacheMgrCallbacks),
 466                          Fcb);
 467
 468     ExInitializeResourceLite(&Vcb->DirResource);
 469
 470     KeInitializeSpinLock(&Vcb->FcbListLock);
 471
 472     /* Get serial number */
 473     NewDeviceObject->Vpb->SerialNumber = Vcb->NtfsInfo.SerialNumber;
 474
 475     /* Get volume label */
 476     NewDeviceObject->Vpb->VolumeLabelLength = Vcb->NtfsInfo.VolumeLabelLength;
 477     RtlCopyMemory(NewDeviceObject->Vpb->VolumeLabel,
 478                   Vcb->NtfsInfo.VolumeLabel,
 479                   Vcb->NtfsInfo.VolumeLabelLength);
 480
 481     Status = STATUS_SUCCESS;
 482
 483 ByeBye:
 484     if (!NT_SUCCESS(Status))
 485     {
 486         /* Cleanup */
 487         if (Vcb && Vcb->StreamFileObject)
 488             ObDereferenceObject(Vcb->StreamFileObject);
 489
 490         if (Fcb)
 491             ExFreePool(Fcb);
 492
 493         if (Ccb)
 494             ExFreePool(Ccb);
 495
 496         if (NewDeviceObject)
 497             IoDeleteDevice(NewDeviceObject);
 498     }
 499
 500     DPRINT("NtfsMountVolume() done (Status: %lx)\n", Status);
 501
 502     return Status;
 503 }
 504
 505
 506 static
 507 NTSTATUS
 508 NtfsVerifyVolume(PDEVICE_OBJECT DeviceObject,
 509                  PIRP Irp)
 510 {
 511     UNREFERENCED_PARAMETER(DeviceObject);
 512     UNREFERENCED_PARAMETER(Irp);
 513     DPRINT1("NtfsVerifyVolume() called\n");
 514     return STATUS_WRONG_VOLUME;
 515 }
 516
 517
 518 NTSTATUS
 519 NTAPI
 520 NtfsFsdFileSystemControl(PDEVICE_OBJECT DeviceObject,
 521                          PIRP Irp)
 522 {
 523     PIO_STACK_LOCATION Stack;
 524     NTSTATUS Status;
 525
 526     DPRINT1("NtfsFileSystemControl() called\n");
 527
 528     Stack = IoGetCurrentIrpStackLocation(Irp);
 529
 530     switch (Stack->MinorFunction)
 531     {
 532         case IRP_MN_KERNEL_CALL:
 533         case IRP_MN_USER_FS_REQUEST:
 534             DPRINT("NTFS: IRP_MN_USER_FS_REQUEST/IRP_MN_KERNEL_CALL\n");
 535             Status = STATUS_INVALID_DEVICE_REQUEST;
 536             break;
 537
 538         case IRP_MN_MOUNT_VOLUME:
 539             DPRINT("NTFS: IRP_MN_MOUNT_VOLUME\n");
 540             Status = NtfsMountVolume(DeviceObject, Irp);
 541             break;
 542
 543         case IRP_MN_VERIFY_VOLUME:
 544             DPRINT1("NTFS: IRP_MN_VERIFY_VOLUME\n");
 545             Status = NtfsVerifyVolume(DeviceObject, Irp);
 546             break;
 547
 548         default:
 549             DPRINT("NTFS FSC: MinorFunction %d\n", Stack->MinorFunction);
 550             Status = STATUS_INVALID_DEVICE_REQUEST;
 551             break;
 552     }
 553
 554     Irp->IoStatus.Status = Status;
 555     Irp->IoStatus.Information = 0;
 556
 557     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 558
 559     return Status;
 560 }
 561
 562 /* EOF */