3 * Copyright (C) 2002 ReactOS Team
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.
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.
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.
20 * COPYRIGHT: See COPYING in the top level directory
21 * PROJECT: ReactOS kernel
22 * FILE: drivers/fs/vfat/fsctl.c
23 * PURPOSE: VFAT Filesystem
26 /* INCLUDES *****************************************************************/
31 /* FUNCTIONS ****************************************************************/
33 #define CACHEPAGESIZE(pDeviceExt) ((pDeviceExt)->FatInfo.BytesPerCluster > PAGE_SIZE ? \
34 (pDeviceExt)->FatInfo.BytesPerCluster : PAGE_SIZE)
36 #define VOLUME_IS_DIRTY 0x00000001
39 VfatHasFileSystem(PDEVICE_OBJECT DeviceToMount
,
40 PBOOLEAN RecognizedFS
,
44 PARTITION_INFORMATION PartitionInfo
;
45 DISK_GEOMETRY DiskGeometry
;
50 struct _BootSector
* Boot
;
51 struct _BootSectorFatX
* BootFatX
;
52 BOOLEAN PartitionInfoIsValid
= FALSE
;
54 DPRINT("VfatHasFileSystem\n");
56 *RecognizedFS
= FALSE
;
58 Size
= sizeof(DISK_GEOMETRY
);
59 Status
= VfatBlockDeviceIoControl(DeviceToMount
,
60 IOCTL_DISK_GET_DRIVE_GEOMETRY
,
66 if (!NT_SUCCESS(Status
))
68 DPRINT("VfatBlockDeviceIoControl faild (%x)\n", Status
);
71 FatInfo
.FixedMedia
= DiskGeometry
.MediaType
== FixedMedia
? TRUE
: FALSE
;
72 if (DiskGeometry
.MediaType
== FixedMedia
|| DiskGeometry
.MediaType
== RemovableMedia
)
74 // We have found a hard disk
75 Size
= sizeof(PARTITION_INFORMATION
);
76 Status
= VfatBlockDeviceIoControl(DeviceToMount
,
77 IOCTL_DISK_GET_PARTITION_INFO
,
83 if (!NT_SUCCESS(Status
))
85 DPRINT("VfatBlockDeviceIoControl faild (%x)\n", Status
);
88 PartitionInfoIsValid
= TRUE
;
89 DPRINT("Partition Information:\n");
90 DPRINT("StartingOffset %u\n", PartitionInfo
.StartingOffset
.QuadPart
/ 512);
91 DPRINT("PartitionLength %u\n", PartitionInfo
.PartitionLength
.QuadPart
/ 512);
92 DPRINT("HiddenSectors %u\n", PartitionInfo
.HiddenSectors
);
93 DPRINT("PartitionNumber %u\n", PartitionInfo
.PartitionNumber
);
94 DPRINT("PartitionType %u\n", PartitionInfo
.PartitionType
);
95 DPRINT("BootIndicator %u\n", PartitionInfo
.BootIndicator
);
96 DPRINT("RecognizedPartition %u\n", PartitionInfo
.RecognizedPartition
);
97 DPRINT("RewritePartition %u\n", PartitionInfo
.RewritePartition
);
98 if (PartitionInfo
.PartitionType
)
100 if (PartitionInfo
.PartitionType
== PARTITION_FAT_12
||
101 PartitionInfo
.PartitionType
== PARTITION_FAT_16
||
102 PartitionInfo
.PartitionType
== PARTITION_HUGE
||
103 PartitionInfo
.PartitionType
== PARTITION_FAT32
||
104 PartitionInfo
.PartitionType
== PARTITION_FAT32_XINT13
||
105 PartitionInfo
.PartitionType
== PARTITION_XINT13
)
107 *RecognizedFS
= TRUE
;
110 else if (DiskGeometry
.MediaType
== RemovableMedia
&&
111 PartitionInfo
.PartitionNumber
> 0 &&
112 PartitionInfo
.StartingOffset
.QuadPart
== 0 &&
113 PartitionInfo
.PartitionLength
.QuadPart
> 0)
115 /* This is possible a removable media formated as super floppy */
116 *RecognizedFS
= TRUE
;
119 else if (DiskGeometry
.MediaType
== Unknown
)
122 * Floppy disk driver can return Unknown as media type if it
123 * doesn't know yet what floppy in the drive really is. This is
124 * perfectly correct to do under Windows.
126 *RecognizedFS
= TRUE
;
127 DiskGeometry
.BytesPerSector
= 512;
131 *RecognizedFS
= TRUE
;
136 Boot
= ExAllocatePoolWithTag(NonPagedPool
, DiskGeometry
.BytesPerSector
, TAG_VFAT
);
139 return STATUS_INSUFFICIENT_RESOURCES
;
144 /* Try to recognize FAT12/FAT16/FAT32 partitions */
145 Status
= VfatReadDisk(DeviceToMount
, &Offset
, DiskGeometry
.BytesPerSector
, (PUCHAR
) Boot
, FALSE
);
146 if (NT_SUCCESS(Status
))
148 if (Boot
->Signatur1
!= 0xaa55)
150 *RecognizedFS
= FALSE
;
153 Boot
->BytesPerSector
!= 512 &&
154 Boot
->BytesPerSector
!= 1024 &&
155 Boot
->BytesPerSector
!= 2048 &&
156 Boot
->BytesPerSector
!= 4096)
158 DPRINT1("BytesPerSector %d\n", Boot
->BytesPerSector
);
159 *RecognizedFS
= FALSE
;
163 Boot
->FATCount
!= 1 &&
166 DPRINT1("FATCount %d\n", Boot
->FATCount
);
167 *RecognizedFS
= FALSE
;
171 Boot
->Media
!= 0xf0 &&
172 Boot
->Media
!= 0xf8 &&
173 Boot
->Media
!= 0xf9 &&
174 Boot
->Media
!= 0xfa &&
175 Boot
->Media
!= 0xfb &&
176 Boot
->Media
!= 0xfc &&
177 Boot
->Media
!= 0xfd &&
178 Boot
->Media
!= 0xfe &&
181 DPRINT1("Media %02x\n", Boot
->Media
);
182 *RecognizedFS
= FALSE
;
186 Boot
->SectorsPerCluster
!= 1 &&
187 Boot
->SectorsPerCluster
!= 2 &&
188 Boot
->SectorsPerCluster
!= 4 &&
189 Boot
->SectorsPerCluster
!= 8 &&
190 Boot
->SectorsPerCluster
!= 16 &&
191 Boot
->SectorsPerCluster
!= 32 &&
192 Boot
->SectorsPerCluster
!= 64 &&
193 Boot
->SectorsPerCluster
!= 128)
195 DPRINT1("SectorsPerCluster %02x\n", Boot
->SectorsPerCluster
);
196 *RecognizedFS
= FALSE
;
200 Boot
->BytesPerSector
* Boot
->SectorsPerCluster
> 32 * 1024)
202 DPRINT1("ClusterSize %dx\n", Boot
->BytesPerSector
* Boot
->SectorsPerCluster
);
203 *RecognizedFS
= FALSE
;
208 FatInfo
.VolumeID
= Boot
->VolumeID
;
209 FatInfo
.FATStart
= Boot
->ReservedSectors
;
210 FatInfo
.FATCount
= Boot
->FATCount
;
211 FatInfo
.FATSectors
= Boot
->FATSectors
? Boot
->FATSectors
: ((struct _BootSector32
*) Boot
)->FATSectors32
;
212 FatInfo
.BytesPerSector
= Boot
->BytesPerSector
;
213 FatInfo
.SectorsPerCluster
= Boot
->SectorsPerCluster
;
214 FatInfo
.BytesPerCluster
= FatInfo
.BytesPerSector
* FatInfo
.SectorsPerCluster
;
215 FatInfo
.rootDirectorySectors
= ((Boot
->RootEntries
* 32) + Boot
->BytesPerSector
- 1) / Boot
->BytesPerSector
;
216 FatInfo
.rootStart
= FatInfo
.FATStart
+ FatInfo
.FATCount
* FatInfo
.FATSectors
;
217 FatInfo
.dataStart
= FatInfo
.rootStart
+ FatInfo
.rootDirectorySectors
;
218 FatInfo
.Sectors
= Sectors
= Boot
->Sectors
? Boot
->Sectors
: Boot
->SectorsHuge
;
219 Sectors
-= Boot
->ReservedSectors
+ FatInfo
.FATCount
* FatInfo
.FATSectors
+ FatInfo
.rootDirectorySectors
;
220 FatInfo
.NumberOfClusters
= Sectors
/ Boot
->SectorsPerCluster
;
221 if (FatInfo
.NumberOfClusters
< 4085)
224 FatInfo
.FatType
= FAT12
;
225 FatInfo
.RootCluster
= (FatInfo
.rootStart
- 1) / FatInfo
.SectorsPerCluster
;
227 else if (FatInfo
.NumberOfClusters
>= 65525)
230 FatInfo
.FatType
= FAT32
;
231 FatInfo
.RootCluster
= ((struct _BootSector32
*) Boot
)->RootCluster
;
232 FatInfo
.rootStart
= FatInfo
.dataStart
+ ((FatInfo
.RootCluster
- 2) * FatInfo
.SectorsPerCluster
);
233 FatInfo
.VolumeID
= ((struct _BootSector32
*) Boot
)->VolumeID
;
238 FatInfo
.FatType
= FAT16
;
239 FatInfo
.RootCluster
= FatInfo
.rootStart
/ FatInfo
.SectorsPerCluster
;
241 if (PartitionInfoIsValid
&&
242 FatInfo
.Sectors
> PartitionInfo
.PartitionLength
.QuadPart
/ FatInfo
.BytesPerSector
)
244 *RecognizedFS
= FALSE
;
247 if (pFatInfo
&& *RecognizedFS
)
257 if (!*RecognizedFS
&& PartitionInfoIsValid
)
259 BootFatX
= ExAllocatePoolWithTag(NonPagedPool
, sizeof(struct _BootSectorFatX
), TAG_VFAT
);
260 if (BootFatX
== NULL
)
263 return STATUS_INSUFFICIENT_RESOURCES
;
268 /* Try to recognize FATX16/FATX32 partitions (Xbox) */
269 Status
= VfatReadDisk(DeviceToMount
, &Offset
, sizeof(struct _BootSectorFatX
), (PUCHAR
) BootFatX
, FALSE
);
270 if (NT_SUCCESS(Status
))
272 *RecognizedFS
= TRUE
;
273 if (BootFatX
->SysType
[0] != 'F' ||
274 BootFatX
->SysType
[1] != 'A' ||
275 BootFatX
->SysType
[2] != 'T' ||
276 BootFatX
->SysType
[3] != 'X')
278 DPRINT1("SysType %c%c%c%c\n", BootFatX
->SysType
[0], BootFatX
->SysType
[1], BootFatX
->SysType
[2], BootFatX
->SysType
[3]);
283 BootFatX
->SectorsPerCluster
!= 1 &&
284 BootFatX
->SectorsPerCluster
!= 2 &&
285 BootFatX
->SectorsPerCluster
!= 4 &&
286 BootFatX
->SectorsPerCluster
!= 8 &&
287 BootFatX
->SectorsPerCluster
!= 16 &&
288 BootFatX
->SectorsPerCluster
!= 32 &&
289 BootFatX
->SectorsPerCluster
!= 64 &&
290 BootFatX
->SectorsPerCluster
!= 128)
292 DPRINT1("SectorsPerCluster %lu\n", BootFatX
->SectorsPerCluster
);
298 FatInfo
.BytesPerSector
= DiskGeometry
.BytesPerSector
;
299 FatInfo
.SectorsPerCluster
= BootFatX
->SectorsPerCluster
;
300 FatInfo
.rootDirectorySectors
= BootFatX
->SectorsPerCluster
;
301 FatInfo
.BytesPerCluster
= BootFatX
->SectorsPerCluster
* DiskGeometry
.BytesPerSector
;
302 FatInfo
.Sectors
= (ULONG
)(PartitionInfo
.PartitionLength
.QuadPart
/ DiskGeometry
.BytesPerSector
);
303 if (FatInfo
.Sectors
/ FatInfo
.SectorsPerCluster
< 65525)
306 FatInfo
.FatType
= FATX16
;
311 FatInfo
.FatType
= FATX32
;
313 FatInfo
.VolumeID
= BootFatX
->VolumeID
;
314 FatInfo
.FATStart
= sizeof(struct _BootSectorFatX
) / DiskGeometry
.BytesPerSector
;
315 FatInfo
.FATCount
= BootFatX
->FATCount
;
317 ROUND_UP(FatInfo
.Sectors
/ FatInfo
.SectorsPerCluster
* (FatInfo
.FatType
== FATX16
? 2 : 4), 4096) /
318 FatInfo
.BytesPerSector
;
319 FatInfo
.rootStart
= FatInfo
.FATStart
+ FatInfo
.FATCount
* FatInfo
.FATSectors
;
320 FatInfo
.RootCluster
= (FatInfo
.rootStart
- 1) / FatInfo
.SectorsPerCluster
;
321 FatInfo
.dataStart
= FatInfo
.rootStart
+ FatInfo
.rootDirectorySectors
;
322 FatInfo
.NumberOfClusters
= (FatInfo
.Sectors
- FatInfo
.dataStart
) / FatInfo
.SectorsPerCluster
;
324 if (pFatInfo
&& *RecognizedFS
)
330 ExFreePool(BootFatX
);
333 DPRINT("VfatHasFileSystem done\n");
338 VfatMountDevice(PDEVICE_EXTENSION DeviceExt
,
339 PDEVICE_OBJECT DeviceToMount
)
341 * FUNCTION: Mounts the device
345 BOOLEAN RecognizedFS
;
347 DPRINT("Mounting VFAT device...\n");
349 Status
= VfatHasFileSystem(DeviceToMount
, &RecognizedFS
, &DeviceExt
->FatInfo
);
350 if (!NT_SUCCESS(Status
))
354 DPRINT("MountVfatdev %d, PAGE_SIZE = %d\n", DeviceExt
->FatInfo
.BytesPerCluster
, PAGE_SIZE
);
357 return(STATUS_SUCCESS
);
362 VfatMount (PVFAT_IRP_CONTEXT IrpContext
)
364 * FUNCTION: Mount the filesystem
367 PDEVICE_OBJECT DeviceObject
= NULL
;
368 PDEVICE_EXTENSION DeviceExt
= NULL
;
369 BOOLEAN RecognizedFS
;
372 PVFATFCB VolumeFcb
= NULL
;
374 PDEVICE_OBJECT DeviceToMount
;
375 UNICODE_STRING NameU
= RTL_CONSTANT_STRING(L
"\\$$Fat$$");
376 UNICODE_STRING VolumeNameU
= RTL_CONSTANT_STRING(L
"\\$$Volume$$");
381 DPRINT("VfatMount(IrpContext %p)\n", IrpContext
);
385 if (IrpContext
->DeviceObject
!= VfatGlobalData
->DeviceObject
)
387 Status
= STATUS_INVALID_DEVICE_REQUEST
;
391 DeviceToMount
= IrpContext
->Stack
->Parameters
.MountVolume
.DeviceObject
;
393 Status
= VfatHasFileSystem (DeviceToMount
, &RecognizedFS
, &FatInfo
);
394 if (!NT_SUCCESS(Status
))
399 if (RecognizedFS
== FALSE
)
401 DPRINT("VFAT: Unrecognized Volume\n");
402 Status
= STATUS_UNRECOGNIZED_VOLUME
;
406 /* Use prime numbers for the table size */
407 if (FatInfo
.FatType
== FAT12
)
409 HashTableSize
= 4099; // 4096 = 4 * 1024
411 else if (FatInfo
.FatType
== FAT16
||
412 FatInfo
.FatType
== FATX16
)
414 HashTableSize
= 16411; // 16384 = 16 * 1024
418 HashTableSize
= 65537; // 65536 = 64 * 1024;
420 HashTableSize
= FCB_HASH_TABLE_SIZE
;
421 DPRINT("VFAT: Recognized volume\n");
422 Status
= IoCreateDevice(VfatGlobalData
->DriverObject
,
423 ROUND_UP(sizeof (DEVICE_EXTENSION
), sizeof(ULONG
)) + sizeof(HASHENTRY
*) * HashTableSize
,
425 FILE_DEVICE_FILE_SYSTEM
,
429 if (!NT_SUCCESS(Status
))
434 DeviceObject
->Flags
= DeviceObject
->Flags
| DO_DIRECT_IO
;
435 DeviceExt
= (PVOID
) DeviceObject
->DeviceExtension
;
436 RtlZeroMemory(DeviceExt
, ROUND_UP(sizeof(DEVICE_EXTENSION
), sizeof(ULONG
)) + sizeof(HASHENTRY
*) * HashTableSize
);
437 DeviceExt
->FcbHashTable
= (HASHENTRY
**)((ULONG_PTR
)DeviceExt
+ ROUND_UP(sizeof(DEVICE_EXTENSION
), sizeof(ULONG
)));
438 DeviceExt
->HashTableSize
= HashTableSize
;
440 /* use same vpb as device disk */
441 DeviceObject
->Vpb
= DeviceToMount
->Vpb
;
442 Status
= VfatMountDevice(DeviceExt
, DeviceToMount
);
443 if (!NT_SUCCESS(Status
))
445 /* FIXME: delete device object */
449 DPRINT("BytesPerSector: %d\n", DeviceExt
->FatInfo
.BytesPerSector
);
450 DPRINT("SectorsPerCluster: %d\n", DeviceExt
->FatInfo
.SectorsPerCluster
);
451 DPRINT("FATCount: %d\n", DeviceExt
->FatInfo
.FATCount
);
452 DPRINT("FATSectors: %d\n", DeviceExt
->FatInfo
.FATSectors
);
453 DPRINT("RootStart: %d\n", DeviceExt
->FatInfo
.rootStart
);
454 DPRINT("DataStart: %d\n", DeviceExt
->FatInfo
.dataStart
);
455 if (DeviceExt
->FatInfo
.FatType
== FAT32
)
457 DPRINT("RootCluster: %d\n", DeviceExt
->FatInfo
.RootCluster
);
460 switch (DeviceExt
->FatInfo
.FatType
)
463 DeviceExt
->GetNextCluster
= FAT12GetNextCluster
;
464 DeviceExt
->FindAndMarkAvailableCluster
= FAT12FindAndMarkAvailableCluster
;
465 DeviceExt
->WriteCluster
= FAT12WriteCluster
;
466 DeviceExt
->CleanShutBitMask
= 0;
471 DeviceExt
->GetNextCluster
= FAT16GetNextCluster
;
472 DeviceExt
->FindAndMarkAvailableCluster
= FAT16FindAndMarkAvailableCluster
;
473 DeviceExt
->WriteCluster
= FAT16WriteCluster
;
474 DeviceExt
->CleanShutBitMask
= 0x8000;
479 DeviceExt
->GetNextCluster
= FAT32GetNextCluster
;
480 DeviceExt
->FindAndMarkAvailableCluster
= FAT32FindAndMarkAvailableCluster
;
481 DeviceExt
->WriteCluster
= FAT32WriteCluster
;
482 DeviceExt
->CleanShutBitMask
= 0x80000000;
486 if (DeviceExt
->FatInfo
.FatType
== FATX16
487 || DeviceExt
->FatInfo
.FatType
== FATX32
)
489 DeviceExt
->Flags
|= VCB_IS_FATX
;
490 DeviceExt
->GetNextDirEntry
= FATXGetNextDirEntry
;
491 DeviceExt
->BaseDateYear
= 2000;
495 DeviceExt
->GetNextDirEntry
= FATGetNextDirEntry
;
496 DeviceExt
->BaseDateYear
= 1980;
499 DeviceExt
->StorageDevice
= DeviceToMount
;
500 DeviceExt
->StorageDevice
->Vpb
->DeviceObject
= DeviceObject
;
501 DeviceExt
->StorageDevice
->Vpb
->RealDevice
= DeviceExt
->StorageDevice
;
502 DeviceExt
->StorageDevice
->Vpb
->Flags
|= VPB_MOUNTED
;
503 DeviceObject
->StackSize
= DeviceExt
->StorageDevice
->StackSize
+ 1;
504 DeviceObject
->Flags
&= ~DO_DEVICE_INITIALIZING
;
506 DPRINT("FsDeviceObject %p\n", DeviceObject
);
508 /* Initialize this resource early ... it's used in VfatCleanup */
509 ExInitializeResourceLite(&DeviceExt
->DirResource
);
511 DeviceExt
->FATFileObject
= IoCreateStreamFileObject(NULL
, DeviceExt
->StorageDevice
);
512 Fcb
= vfatNewFCB(DeviceExt
, &NameU
);
515 Status
= STATUS_INSUFFICIENT_RESOURCES
;
518 Ccb
= ExAllocateFromNPagedLookasideList(&VfatGlobalData
->CcbLookasideList
);
521 Status
= STATUS_INSUFFICIENT_RESOURCES
;
525 RtlZeroMemory(Ccb
, sizeof (VFATCCB
));
526 DeviceExt
->FATFileObject
->FsContext
= Fcb
;
527 DeviceExt
->FATFileObject
->FsContext2
= Ccb
;
528 DeviceExt
->FATFileObject
->SectionObjectPointer
= &Fcb
->SectionObjectPointers
;
529 DeviceExt
->FATFileObject
->PrivateCacheMap
= NULL
;
530 DeviceExt
->FATFileObject
->Vpb
= DeviceObject
->Vpb
;
531 Fcb
->FileObject
= DeviceExt
->FATFileObject
;
533 Fcb
->Flags
|= FCB_IS_FAT
;
535 Fcb
->RFCB
.FileSize
.QuadPart
= DeviceExt
->FatInfo
.FATSectors
* DeviceExt
->FatInfo
.BytesPerSector
;
536 Fcb
->RFCB
.ValidDataLength
= Fcb
->RFCB
.FileSize
;
537 Fcb
->RFCB
.AllocationSize
= Fcb
->RFCB
.FileSize
;
539 CcInitializeCacheMap(DeviceExt
->FATFileObject
,
540 (PCC_FILE_SIZES
)(&Fcb
->RFCB
.AllocationSize
),
542 &VfatGlobalData
->CacheMgrCallbacks
,
545 DeviceExt
->LastAvailableCluster
= 2;
546 ExInitializeResourceLite(&DeviceExt
->FatResource
);
548 InitializeListHead(&DeviceExt
->FcbListHead
);
550 VolumeFcb
= vfatNewFCB(DeviceExt
, &VolumeNameU
);
551 if (VolumeFcb
== NULL
)
553 Status
= STATUS_INSUFFICIENT_RESOURCES
;
556 VolumeFcb
->Flags
= FCB_IS_VOLUME
;
557 VolumeFcb
->RFCB
.FileSize
.QuadPart
= DeviceExt
->FatInfo
.Sectors
* DeviceExt
->FatInfo
.BytesPerSector
;
558 VolumeFcb
->RFCB
.ValidDataLength
= VolumeFcb
->RFCB
.FileSize
;
559 VolumeFcb
->RFCB
.AllocationSize
= VolumeFcb
->RFCB
.FileSize
;
560 DeviceExt
->VolumeFcb
= VolumeFcb
;
562 ExAcquireResourceExclusiveLite(&VfatGlobalData
->VolumeListLock
, TRUE
);
563 InsertHeadList(&VfatGlobalData
->VolumeListHead
, &DeviceExt
->VolumeListEntry
);
564 ExReleaseResourceLite(&VfatGlobalData
->VolumeListLock
);
566 /* read serial number */
567 DeviceObject
->Vpb
->SerialNumber
= DeviceExt
->FatInfo
.VolumeID
;
569 /* read volume label */
570 ReadVolumeLabel(DeviceExt
, DeviceObject
->Vpb
);
572 /* read clean shutdown bit status */
573 Status
= GetNextCluster(DeviceExt
, 1, &eocMark
);
574 if (NT_SUCCESS(Status
))
576 if (eocMark
& DeviceExt
->CleanShutBitMask
)
578 /* unset clean shutdown bit */
579 eocMark
&= ~DeviceExt
->CleanShutBitMask
;
580 WriteCluster(DeviceExt
, 1, eocMark
);
581 VolumeFcb
->Flags
|= VCB_CLEAR_DIRTY
;
584 VolumeFcb
->Flags
|= VCB_IS_DIRTY
;
586 Status
= STATUS_SUCCESS
;
589 if (!NT_SUCCESS(Status
))
592 if (DeviceExt
&& DeviceExt
->FATFileObject
)
593 ObDereferenceObject (DeviceExt
->FATFileObject
);
599 IoDeleteDevice(DeviceObject
);
601 vfatDestroyFCB(VolumeFcb
);
608 VfatVerify (PVFAT_IRP_CONTEXT IrpContext
)
610 * FUNCTION: Verify the filesystem
613 PDEVICE_OBJECT DeviceToVerify
;
614 NTSTATUS Status
= STATUS_SUCCESS
;
616 BOOLEAN RecognizedFS
;
617 PDEVICE_EXTENSION DeviceExt
= IrpContext
->DeviceExt
;
619 DPRINT("VfatVerify(IrpContext %p)\n", IrpContext
);
621 DeviceToVerify
= IrpContext
->Stack
->Parameters
.VerifyVolume
.DeviceObject
;
622 Status
= VfatBlockDeviceIoControl(DeviceToVerify
,
623 IOCTL_DISK_CHECK_VERIFY
,
629 DeviceToVerify
->Flags
&= ~DO_VERIFY_VOLUME
;
630 if (!NT_SUCCESS(Status
) && Status
!= STATUS_VERIFY_REQUIRED
)
632 DPRINT("VfatBlockDeviceIoControl() failed (Status %lx)\n", Status
);
633 Status
= STATUS_WRONG_VOLUME
;
637 Status
= VfatHasFileSystem(DeviceToVerify
, &RecognizedFS
, &FatInfo
);
638 if (!NT_SUCCESS(Status
) || RecognizedFS
== FALSE
)
640 Status
= STATUS_WRONG_VOLUME
;
642 else if (sizeof(FATINFO
) == RtlCompareMemory(&FatInfo
, &DeviceExt
->FatInfo
, sizeof(FATINFO
)))
646 * Preformated floppy disks have very often a serial number of 0000:0000.
647 * We should calculate a crc sum over the sectors from the root directory as secondary volume number.
648 * Each write to the root directory must update this crc sum.
654 Status
= STATUS_WRONG_VOLUME
;
663 VfatGetVolumeBitmap(PVFAT_IRP_CONTEXT IrpContext
)
665 DPRINT("VfatGetVolumeBitmap (IrpContext %p)\n", IrpContext
);
667 return STATUS_INVALID_DEVICE_REQUEST
;
672 VfatGetRetrievalPointers(PVFAT_IRP_CONTEXT IrpContext
)
674 PIO_STACK_LOCATION Stack
;
676 PRETRIEVAL_POINTERS_BUFFER RetrievalPointers
;
677 PFILE_OBJECT FileObject
;
678 ULONG MaxExtentCount
;
680 PDEVICE_EXTENSION DeviceExt
;
682 ULONG CurrentCluster
;
686 DPRINT("VfatGetRetrievalPointers(IrpContext %p)\n", IrpContext
);
688 DeviceExt
= IrpContext
->DeviceExt
;
689 FileObject
= IrpContext
->FileObject
;
690 Stack
= IrpContext
->Stack
;
691 if (Stack
->Parameters
.DeviceIoControl
.InputBufferLength
< sizeof(STARTING_VCN_INPUT_BUFFER
) ||
692 Stack
->Parameters
.DeviceIoControl
.Type3InputBuffer
== NULL
)
694 return STATUS_INVALID_PARAMETER
;
696 if (IrpContext
->Irp
->UserBuffer
== NULL
||
697 Stack
->Parameters
.DeviceIoControl
.OutputBufferLength
< sizeof(RETRIEVAL_POINTERS_BUFFER
))
699 return STATUS_BUFFER_TOO_SMALL
;
702 Fcb
= FileObject
->FsContext
;
704 ExAcquireResourceSharedLite(&Fcb
->MainResource
, TRUE
);
706 Vcn
= ((PSTARTING_VCN_INPUT_BUFFER
)Stack
->Parameters
.DeviceIoControl
.Type3InputBuffer
)->StartingVcn
;
707 RetrievalPointers
= IrpContext
->Irp
->UserBuffer
;
709 MaxExtentCount
= ((Stack
->Parameters
.DeviceIoControl
.OutputBufferLength
- sizeof(RetrievalPointers
->ExtentCount
) - sizeof(RetrievalPointers
->StartingVcn
)) / sizeof(RetrievalPointers
->Extents
[0]));
712 if (Vcn
.QuadPart
>= Fcb
->RFCB
.AllocationSize
.QuadPart
/ DeviceExt
->FatInfo
.BytesPerCluster
)
714 Status
= STATUS_INVALID_PARAMETER
;
718 CurrentCluster
= FirstCluster
= vfatDirEntryGetFirstCluster(DeviceExt
, &Fcb
->entry
);
719 Status
= OffsetToCluster(DeviceExt
, FirstCluster
,
720 Vcn
.u
.LowPart
* DeviceExt
->FatInfo
.BytesPerCluster
,
721 &CurrentCluster
, FALSE
);
722 if (!NT_SUCCESS(Status
))
727 RetrievalPointers
->StartingVcn
= Vcn
;
728 RetrievalPointers
->ExtentCount
= 0;
729 RetrievalPointers
->Extents
[0].Lcn
.u
.HighPart
= 0;
730 RetrievalPointers
->Extents
[0].Lcn
.u
.LowPart
= CurrentCluster
- 2;
732 while (CurrentCluster
!= 0xffffffff && RetrievalPointers
->ExtentCount
< MaxExtentCount
)
735 LastCluster
= CurrentCluster
;
736 Status
= NextCluster(DeviceExt
, CurrentCluster
, &CurrentCluster
, FALSE
);
738 if (!NT_SUCCESS(Status
))
743 if (LastCluster
+ 1 != CurrentCluster
)
745 RetrievalPointers
->Extents
[RetrievalPointers
->ExtentCount
].NextVcn
= Vcn
;
746 RetrievalPointers
->ExtentCount
++;
747 if (RetrievalPointers
->ExtentCount
< MaxExtentCount
)
749 RetrievalPointers
->Extents
[RetrievalPointers
->ExtentCount
].Lcn
.u
.HighPart
= 0;
750 RetrievalPointers
->Extents
[RetrievalPointers
->ExtentCount
].Lcn
.u
.LowPart
= CurrentCluster
- 2;
755 IrpContext
->Irp
->IoStatus
.Information
= sizeof(RETRIEVAL_POINTERS_BUFFER
) + (sizeof(RetrievalPointers
->Extents
[0]) * (RetrievalPointers
->ExtentCount
- 1));
756 Status
= STATUS_SUCCESS
;
759 ExReleaseResourceLite(&Fcb
->MainResource
);
765 VfatMoveFile(PVFAT_IRP_CONTEXT IrpContext
)
767 DPRINT("VfatMoveFile(IrpContext %p)\n", IrpContext
);
769 return STATUS_INVALID_DEVICE_REQUEST
;
772 #ifdef USE_ROS_CC_AND_FS
774 VfatRosQueryLcnMapping(PVFAT_IRP_CONTEXT IrpContext
)
776 PDEVICE_EXTENSION DeviceExt
;
777 PROS_QUERY_LCN_MAPPING LcnQuery
;
778 PIO_STACK_LOCATION Stack
;
780 DPRINT("VfatRosQueryLcnMapping(IrpContext %p)\n", IrpContext
);
782 DeviceExt
= IrpContext
->DeviceExt
;
783 Stack
= IrpContext
->Stack
;
784 if (IrpContext
->Irp
->AssociatedIrp
.SystemBuffer
== NULL
||
785 Stack
->Parameters
.DeviceIoControl
.OutputBufferLength
< sizeof(ROS_QUERY_LCN_MAPPING
))
787 return STATUS_BUFFER_TOO_SMALL
;
789 LcnQuery
= (PROS_QUERY_LCN_MAPPING
)(IrpContext
->Irp
->AssociatedIrp
.SystemBuffer
);
790 LcnQuery
->LcnDiskOffset
.QuadPart
= DeviceExt
->FatInfo
.dataStart
* DeviceExt
->FatInfo
.BytesPerSector
;
791 IrpContext
->Irp
->IoStatus
.Information
= sizeof(ROS_QUERY_LCN_MAPPING
);
792 return(STATUS_SUCCESS
);
797 VfatIsVolumeDirty(PVFAT_IRP_CONTEXT IrpContext
)
801 DPRINT("VfatIsVolumeDirty(IrpContext %p)\n", IrpContext
);
803 if (IrpContext
->Stack
->Parameters
.FileSystemControl
.OutputBufferLength
!= sizeof(ULONG
))
804 return STATUS_INVALID_BUFFER_SIZE
;
805 else if (!IrpContext
->Irp
->AssociatedIrp
.SystemBuffer
)
806 return STATUS_INVALID_USER_BUFFER
;
808 Flags
= (PULONG
)IrpContext
->Irp
->AssociatedIrp
.SystemBuffer
;
811 if (IrpContext
->DeviceExt
->VolumeFcb
->Flags
& VCB_IS_DIRTY
812 && !(IrpContext
->DeviceExt
->VolumeFcb
->Flags
& VCB_CLEAR_DIRTY
))
814 *Flags
|= VOLUME_IS_DIRTY
;
817 return STATUS_SUCCESS
;
821 VfatMarkVolumeDirty(PVFAT_IRP_CONTEXT IrpContext
)
824 PDEVICE_EXTENSION DeviceExt
;
825 NTSTATUS Status
= STATUS_SUCCESS
;
827 DPRINT("VfatMarkVolumeDirty(IrpContext %p)\n", IrpContext
);
828 DeviceExt
= IrpContext
->DeviceExt
;
830 if (!(DeviceExt
->VolumeFcb
->Flags
& VCB_IS_DIRTY
))
832 Status
= GetNextCluster(DeviceExt
, 1, &eocMark
);
833 if (NT_SUCCESS(Status
))
835 /* unset clean shutdown bit */
836 eocMark
&= ~DeviceExt
->CleanShutBitMask
;
837 Status
= WriteCluster(DeviceExt
, 1, eocMark
);
841 DeviceExt
->VolumeFcb
->Flags
&= ~VCB_CLEAR_DIRTY
;
846 NTSTATUS
VfatFileSystemControl(PVFAT_IRP_CONTEXT IrpContext
)
848 * FUNCTION: File system control
854 DPRINT("VfatFileSystemControl(IrpContext %p)\n", IrpContext
);
857 ASSERT(IrpContext
->Irp
);
858 ASSERT(IrpContext
->Stack
);
860 IrpContext
->Irp
->IoStatus
.Information
= 0;
862 switch (IrpContext
->MinorFunction
)
864 case IRP_MN_USER_FS_REQUEST
:
865 switch(IrpContext
->Stack
->Parameters
.DeviceIoControl
.IoControlCode
)
867 case FSCTL_GET_VOLUME_BITMAP
:
868 Status
= VfatGetVolumeBitmap(IrpContext
);
870 case FSCTL_GET_RETRIEVAL_POINTERS
:
871 Status
= VfatGetRetrievalPointers(IrpContext
);
873 case FSCTL_MOVE_FILE
:
874 Status
= VfatMoveFile(IrpContext
);
876 #ifdef USE_ROS_CC_AND_FS
877 case FSCTL_ROS_QUERY_LCN_MAPPING
:
878 Status
= VfatRosQueryLcnMapping(IrpContext
);
881 case FSCTL_IS_VOLUME_DIRTY
:
882 Status
= VfatIsVolumeDirty(IrpContext
);
884 case FSCTL_MARK_VOLUME_DIRTY
:
885 Status
= VfatMarkVolumeDirty(IrpContext
);
888 Status
= STATUS_INVALID_DEVICE_REQUEST
;
892 case IRP_MN_MOUNT_VOLUME
:
893 Status
= VfatMount(IrpContext
);
896 case IRP_MN_VERIFY_VOLUME
:
897 DPRINT("VFATFS: IRP_MN_VERIFY_VOLUME\n");
898 Status
= VfatVerify(IrpContext
);
902 DPRINT("VFAT FSC: MinorFunction %d\n", IrpContext
->MinorFunction
);
903 Status
= STATUS_INVALID_DEVICE_REQUEST
;
907 IrpContext
->Irp
->IoStatus
.Status
= Status
;
909 IoCompleteRequest (IrpContext
->Irp
, IO_NO_INCREMENT
);
910 VfatFreeIrpContext(IrpContext
);