[FASTFAT]
[reactos.git] / reactos / drivers / filesystems / fastfat / 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 along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19 /*
20 * COPYRIGHT: See COPYING in the top level directory
21 * PROJECT: ReactOS kernel
22 * FILE: drivers/fs/vfat/fsctl.c
23 * PURPOSE: VFAT Filesystem
24 */
25
26 /* INCLUDES *****************************************************************/
27
28 #include "vfat.h"
29
30 #define NDEBUG
31 #include <debug.h>
32
33 /* FUNCTIONS ****************************************************************/
34
35 #define CACHEPAGESIZE(pDeviceExt) ((pDeviceExt)->FatInfo.BytesPerCluster > PAGE_SIZE ? \
36 (pDeviceExt)->FatInfo.BytesPerCluster : PAGE_SIZE)
37
38 static
39 NTSTATUS
40 VfatHasFileSystem(
41 PDEVICE_OBJECT DeviceToMount,
42 PBOOLEAN RecognizedFS,
43 PFATINFO pFatInfo)
44 {
45 NTSTATUS Status;
46 PARTITION_INFORMATION PartitionInfo;
47 DISK_GEOMETRY DiskGeometry;
48 FATINFO FatInfo;
49 ULONG Size;
50 ULONG Sectors;
51 LARGE_INTEGER Offset;
52 struct _BootSector* Boot;
53 struct _BootSectorFatX* BootFatX;
54 BOOLEAN PartitionInfoIsValid = FALSE;
55
56 DPRINT("VfatHasFileSystem\n");
57
58 *RecognizedFS = FALSE;
59
60 Size = sizeof(DISK_GEOMETRY);
61 Status = VfatBlockDeviceIoControl(DeviceToMount,
62 IOCTL_DISK_GET_DRIVE_GEOMETRY,
63 NULL,
64 0,
65 &DiskGeometry,
66 &Size,
67 FALSE);
68 if (!NT_SUCCESS(Status))
69 {
70 DPRINT("VfatBlockDeviceIoControl faild (%x)\n", Status);
71 return Status;
72 }
73
74 FatInfo.FixedMedia = DiskGeometry.MediaType == FixedMedia ? TRUE : FALSE;
75 if (DiskGeometry.MediaType == FixedMedia || DiskGeometry.MediaType == RemovableMedia)
76 {
77 // We have found a hard disk
78 Size = sizeof(PARTITION_INFORMATION);
79 Status = VfatBlockDeviceIoControl(DeviceToMount,
80 IOCTL_DISK_GET_PARTITION_INFO,
81 NULL,
82 0,
83 &PartitionInfo,
84 &Size,
85 FALSE);
86 if (!NT_SUCCESS(Status))
87 {
88 DPRINT("VfatBlockDeviceIoControl faild (%x)\n", Status);
89 return Status;
90 }
91
92 DPRINT("Partition Information:\n");
93 DPRINT("StartingOffset %I64x\n", PartitionInfo.StartingOffset.QuadPart / 512);
94 DPRINT("PartitionLength %I64x\n", PartitionInfo.PartitionLength.QuadPart / 512);
95 DPRINT("HiddenSectors %u\n", PartitionInfo.HiddenSectors);
96 DPRINT("PartitionNumber %u\n", PartitionInfo.PartitionNumber);
97 DPRINT("PartitionType %u\n", PartitionInfo.PartitionType);
98 DPRINT("BootIndicator %u\n", PartitionInfo.BootIndicator);
99 DPRINT("RecognizedPartition %u\n", PartitionInfo.RecognizedPartition);
100 DPRINT("RewritePartition %u\n", PartitionInfo.RewritePartition);
101 if (PartitionInfo.PartitionType)
102 {
103 if (PartitionInfo.PartitionType == PARTITION_FAT_12 ||
104 PartitionInfo.PartitionType == PARTITION_FAT_16 ||
105 PartitionInfo.PartitionType == PARTITION_HUGE ||
106 PartitionInfo.PartitionType == PARTITION_FAT32 ||
107 PartitionInfo.PartitionType == PARTITION_FAT32_XINT13 ||
108 PartitionInfo.PartitionType == PARTITION_XINT13)
109 {
110 PartitionInfoIsValid = TRUE;
111 *RecognizedFS = TRUE;
112 }
113 }
114 else if (DiskGeometry.MediaType == RemovableMedia &&
115 PartitionInfo.PartitionNumber > 0 &&
116 PartitionInfo.StartingOffset.QuadPart == 0 &&
117 PartitionInfo.PartitionLength.QuadPart > 0)
118 {
119 /* This is possible a removable media formated as super floppy */
120 PartitionInfoIsValid = TRUE;
121 *RecognizedFS = TRUE;
122 }
123 }
124 else if (DiskGeometry.MediaType == Unknown)
125 {
126 /*
127 * Floppy disk driver can return Unknown as media type if it
128 * doesn't know yet what floppy in the drive really is. This is
129 * perfectly correct to do under Windows.
130 */
131 *RecognizedFS = TRUE;
132 DiskGeometry.BytesPerSector = 512;
133 }
134 else
135 {
136 *RecognizedFS = TRUE;
137 }
138
139 if (*RecognizedFS)
140 {
141 Boot = ExAllocatePoolWithTag(NonPagedPool, DiskGeometry.BytesPerSector, TAG_VFAT);
142 if (Boot == NULL)
143 {
144 return STATUS_INSUFFICIENT_RESOURCES;
145 }
146
147 Offset.QuadPart = 0;
148
149 /* Try to recognize FAT12/FAT16/FAT32 partitions */
150 Status = VfatReadDisk(DeviceToMount, &Offset, DiskGeometry.BytesPerSector, (PUCHAR) Boot, FALSE);
151 if (NT_SUCCESS(Status))
152 {
153 if (Boot->Signatur1 != 0xaa55)
154 {
155 *RecognizedFS = FALSE;
156 }
157
158 if (*RecognizedFS &&
159 Boot->BytesPerSector != 512 &&
160 Boot->BytesPerSector != 1024 &&
161 Boot->BytesPerSector != 2048 &&
162 Boot->BytesPerSector != 4096)
163 {
164 DPRINT1("BytesPerSector %u\n", Boot->BytesPerSector);
165 *RecognizedFS = FALSE;
166 }
167
168 if (*RecognizedFS &&
169 Boot->FATCount != 1 &&
170 Boot->FATCount != 2)
171 {
172 DPRINT1("FATCount %u\n", Boot->FATCount);
173 *RecognizedFS = FALSE;
174 }
175
176 if (*RecognizedFS &&
177 Boot->Media != 0xf0 &&
178 Boot->Media != 0xf8 &&
179 Boot->Media != 0xf9 &&
180 Boot->Media != 0xfa &&
181 Boot->Media != 0xfb &&
182 Boot->Media != 0xfc &&
183 Boot->Media != 0xfd &&
184 Boot->Media != 0xfe &&
185 Boot->Media != 0xff)
186 {
187 DPRINT1("Media %02x\n", Boot->Media);
188 *RecognizedFS = FALSE;
189 }
190
191 if (*RecognizedFS &&
192 Boot->SectorsPerCluster != 1 &&
193 Boot->SectorsPerCluster != 2 &&
194 Boot->SectorsPerCluster != 4 &&
195 Boot->SectorsPerCluster != 8 &&
196 Boot->SectorsPerCluster != 16 &&
197 Boot->SectorsPerCluster != 32 &&
198 Boot->SectorsPerCluster != 64 &&
199 Boot->SectorsPerCluster != 128)
200 {
201 DPRINT1("SectorsPerCluster %02x\n", Boot->SectorsPerCluster);
202 *RecognizedFS = FALSE;
203 }
204
205 if (*RecognizedFS &&
206 Boot->BytesPerSector * Boot->SectorsPerCluster > 32 * 1024)
207 {
208 DPRINT1("ClusterSize %dx\n", Boot->BytesPerSector * Boot->SectorsPerCluster);
209 *RecognizedFS = FALSE;
210 }
211
212 if (*RecognizedFS)
213 {
214 FatInfo.VolumeID = Boot->VolumeID;
215 FatInfo.FATStart = Boot->ReservedSectors;
216 FatInfo.FATCount = Boot->FATCount;
217 FatInfo.FATSectors = Boot->FATSectors ? Boot->FATSectors : ((struct _BootSector32*) Boot)->FATSectors32;
218 FatInfo.BytesPerSector = Boot->BytesPerSector;
219 FatInfo.SectorsPerCluster = Boot->SectorsPerCluster;
220 FatInfo.BytesPerCluster = FatInfo.BytesPerSector * FatInfo.SectorsPerCluster;
221 FatInfo.rootDirectorySectors = ((Boot->RootEntries * 32) + Boot->BytesPerSector - 1) / Boot->BytesPerSector;
222 FatInfo.rootStart = FatInfo.FATStart + FatInfo.FATCount * FatInfo.FATSectors;
223 FatInfo.dataStart = FatInfo.rootStart + FatInfo.rootDirectorySectors;
224 FatInfo.Sectors = Sectors = Boot->Sectors ? Boot->Sectors : Boot->SectorsHuge;
225 Sectors -= Boot->ReservedSectors + FatInfo.FATCount * FatInfo.FATSectors + FatInfo.rootDirectorySectors;
226 FatInfo.NumberOfClusters = Sectors / Boot->SectorsPerCluster;
227 if (FatInfo.NumberOfClusters < 4085)
228 {
229 DPRINT("FAT12\n");
230 FatInfo.FatType = FAT12;
231 FatInfo.RootCluster = (FatInfo.rootStart - 1) / FatInfo.SectorsPerCluster;
232 }
233 else if (FatInfo.NumberOfClusters >= 65525)
234 {
235 DPRINT("FAT32\n");
236 FatInfo.FatType = FAT32;
237 FatInfo.RootCluster = ((struct _BootSector32*) Boot)->RootCluster;
238 FatInfo.rootStart = FatInfo.dataStart + ((FatInfo.RootCluster - 2) * FatInfo.SectorsPerCluster);
239 FatInfo.VolumeID = ((struct _BootSector32*) Boot)->VolumeID;
240 }
241 else
242 {
243 DPRINT("FAT16\n");
244 FatInfo.FatType = FAT16;
245 FatInfo.RootCluster = FatInfo.rootStart / FatInfo.SectorsPerCluster;
246 }
247
248 if (PartitionInfoIsValid &&
249 FatInfo.Sectors > PartitionInfo.PartitionLength.QuadPart / FatInfo.BytesPerSector)
250 {
251 *RecognizedFS = FALSE;
252 }
253
254 if (pFatInfo && *RecognizedFS)
255 {
256 *pFatInfo = FatInfo;
257 }
258 }
259 }
260
261 ExFreePool(Boot);
262 }
263
264 if (!*RecognizedFS && PartitionInfoIsValid)
265 {
266 BootFatX = ExAllocatePoolWithTag(NonPagedPool, sizeof(struct _BootSectorFatX), TAG_VFAT);
267 if (BootFatX == NULL)
268 {
269 *RecognizedFS=FALSE;
270 return STATUS_INSUFFICIENT_RESOURCES;
271 }
272
273 Offset.QuadPart = 0;
274
275 /* Try to recognize FATX16/FATX32 partitions (Xbox) */
276 Status = VfatReadDisk(DeviceToMount, &Offset, sizeof(struct _BootSectorFatX), (PUCHAR) BootFatX, FALSE);
277 if (NT_SUCCESS(Status))
278 {
279 *RecognizedFS = TRUE;
280 if (BootFatX->SysType[0] != 'F' ||
281 BootFatX->SysType[1] != 'A' ||
282 BootFatX->SysType[2] != 'T' ||
283 BootFatX->SysType[3] != 'X')
284 {
285 DPRINT1("SysType %c%c%c%c\n", BootFatX->SysType[0], BootFatX->SysType[1], BootFatX->SysType[2], BootFatX->SysType[3]);
286 *RecognizedFS=FALSE;
287 }
288
289 if (*RecognizedFS &&
290 BootFatX->SectorsPerCluster != 1 &&
291 BootFatX->SectorsPerCluster != 2 &&
292 BootFatX->SectorsPerCluster != 4 &&
293 BootFatX->SectorsPerCluster != 8 &&
294 BootFatX->SectorsPerCluster != 16 &&
295 BootFatX->SectorsPerCluster != 32 &&
296 BootFatX->SectorsPerCluster != 64 &&
297 BootFatX->SectorsPerCluster != 128)
298 {
299 DPRINT1("SectorsPerCluster %lu\n", BootFatX->SectorsPerCluster);
300 *RecognizedFS=FALSE;
301 }
302
303 if (*RecognizedFS)
304 {
305 FatInfo.BytesPerSector = DiskGeometry.BytesPerSector;
306 FatInfo.SectorsPerCluster = BootFatX->SectorsPerCluster;
307 FatInfo.rootDirectorySectors = BootFatX->SectorsPerCluster;
308 FatInfo.BytesPerCluster = BootFatX->SectorsPerCluster * DiskGeometry.BytesPerSector;
309 FatInfo.Sectors = (ULONG)(PartitionInfo.PartitionLength.QuadPart / DiskGeometry.BytesPerSector);
310 if (FatInfo.Sectors / FatInfo.SectorsPerCluster < 65525)
311 {
312 DPRINT("FATX16\n");
313 FatInfo.FatType = FATX16;
314 }
315 else
316 {
317 DPRINT("FATX32\n");
318 FatInfo.FatType = FATX32;
319 }
320 FatInfo.VolumeID = BootFatX->VolumeID;
321 FatInfo.FATStart = sizeof(struct _BootSectorFatX) / DiskGeometry.BytesPerSector;
322 FatInfo.FATCount = BootFatX->FATCount;
323 FatInfo.FATSectors =
324 ROUND_UP(FatInfo.Sectors / FatInfo.SectorsPerCluster * (FatInfo.FatType == FATX16 ? 2 : 4), 4096) /
325 FatInfo.BytesPerSector;
326 FatInfo.rootStart = FatInfo.FATStart + FatInfo.FATCount * FatInfo.FATSectors;
327 FatInfo.RootCluster = (FatInfo.rootStart - 1) / FatInfo.SectorsPerCluster;
328 FatInfo.dataStart = FatInfo.rootStart + FatInfo.rootDirectorySectors;
329 FatInfo.NumberOfClusters = (FatInfo.Sectors - FatInfo.dataStart) / FatInfo.SectorsPerCluster;
330
331 if (pFatInfo && *RecognizedFS)
332 {
333 *pFatInfo = FatInfo;
334 }
335 }
336 }
337 ExFreePool(BootFatX);
338 }
339
340 DPRINT("VfatHasFileSystem done\n");
341 return Status;
342 }
343
344 /*
345 * FUNCTION: Mounts the device
346 */
347 static
348 NTSTATUS
349 VfatMountDevice(
350 PDEVICE_EXTENSION DeviceExt,
351 PDEVICE_OBJECT DeviceToMount)
352 {
353 NTSTATUS Status;
354 BOOLEAN RecognizedFS;
355
356 DPRINT("Mounting VFAT device...\n");
357
358 Status = VfatHasFileSystem(DeviceToMount, &RecognizedFS, &DeviceExt->FatInfo);
359 if (!NT_SUCCESS(Status))
360 {
361 return Status;
362 }
363 DPRINT("MountVfatdev %u, PAGE_SIZE = %d\n", DeviceExt->FatInfo.BytesPerCluster, PAGE_SIZE);
364
365 return STATUS_SUCCESS;
366 }
367
368
369 /*
370 * FUNCTION: Mount the filesystem
371 */
372 static
373 NTSTATUS
374 VfatMount(
375 PVFAT_IRP_CONTEXT IrpContext)
376 {
377 PDEVICE_OBJECT DeviceObject = NULL;
378 PDEVICE_EXTENSION DeviceExt = NULL;
379 BOOLEAN RecognizedFS;
380 NTSTATUS Status;
381 PVFATFCB Fcb = NULL;
382 PVFATFCB VolumeFcb = NULL;
383 PVFATCCB Ccb = NULL;
384 PDEVICE_OBJECT DeviceToMount;
385 PVPB Vpb;
386 UNICODE_STRING NameU = RTL_CONSTANT_STRING(L"\\$$Fat$$");
387 UNICODE_STRING VolumeNameU = RTL_CONSTANT_STRING(L"\\$$Volume$$");
388 ULONG HashTableSize;
389 ULONG eocMark;
390 FATINFO FatInfo;
391
392 DPRINT("VfatMount(IrpContext %p)\n", IrpContext);
393
394 ASSERT(IrpContext);
395
396 if (IrpContext->DeviceObject != VfatGlobalData->DeviceObject)
397 {
398 Status = STATUS_INVALID_DEVICE_REQUEST;
399 goto ByeBye;
400 }
401
402 DeviceToMount = IrpContext->Stack->Parameters.MountVolume.DeviceObject;
403 Vpb = IrpContext->Stack->Parameters.MountVolume.Vpb;
404
405 Status = VfatHasFileSystem(DeviceToMount, &RecognizedFS, &FatInfo);
406 if (!NT_SUCCESS(Status))
407 {
408 goto ByeBye;
409 }
410
411 if (RecognizedFS == FALSE)
412 {
413 DPRINT("VFAT: Unrecognized Volume\n");
414 Status = STATUS_UNRECOGNIZED_VOLUME;
415 goto ByeBye;
416 }
417
418 /* Use prime numbers for the table size */
419 if (FatInfo.FatType == FAT12)
420 {
421 HashTableSize = 4099; // 4096 = 4 * 1024
422 }
423 else if (FatInfo.FatType == FAT16 ||
424 FatInfo.FatType == FATX16)
425 {
426 HashTableSize = 16411; // 16384 = 16 * 1024
427 }
428 else
429 {
430 HashTableSize = 65537; // 65536 = 64 * 1024;
431 }
432 HashTableSize = FCB_HASH_TABLE_SIZE;
433 DPRINT("VFAT: Recognized volume\n");
434 Status = IoCreateDevice(VfatGlobalData->DriverObject,
435 ROUND_UP(sizeof (DEVICE_EXTENSION), sizeof(ULONG)) + sizeof(HASHENTRY*) * HashTableSize,
436 NULL,
437 FILE_DEVICE_DISK_FILE_SYSTEM,
438 DeviceToMount->Characteristics,
439 FALSE,
440 &DeviceObject);
441 if (!NT_SUCCESS(Status))
442 {
443 goto ByeBye;
444 }
445
446 DeviceExt = DeviceObject->DeviceExtension;
447 RtlZeroMemory(DeviceExt, ROUND_UP(sizeof(DEVICE_EXTENSION), sizeof(ULONG)) + sizeof(HASHENTRY*) * HashTableSize);
448 DeviceExt->FcbHashTable = (HASHENTRY**)((ULONG_PTR)DeviceExt + ROUND_UP(sizeof(DEVICE_EXTENSION), sizeof(ULONG)));
449 DeviceExt->HashTableSize = HashTableSize;
450
451 /* use same vpb as device disk */
452 DeviceObject->Vpb = Vpb;
453 DeviceToMount->Vpb = Vpb;
454
455 Status = VfatMountDevice(DeviceExt, DeviceToMount);
456 if (!NT_SUCCESS(Status))
457 {
458 /* FIXME: delete device object */
459 goto ByeBye;
460 }
461
462 DPRINT("BytesPerSector: %u\n", DeviceExt->FatInfo.BytesPerSector);
463 DPRINT("SectorsPerCluster: %u\n", DeviceExt->FatInfo.SectorsPerCluster);
464 DPRINT("FATCount: %u\n", DeviceExt->FatInfo.FATCount);
465 DPRINT("FATSectors: %u\n", DeviceExt->FatInfo.FATSectors);
466 DPRINT("RootStart: %u\n", DeviceExt->FatInfo.rootStart);
467 DPRINT("DataStart: %u\n", DeviceExt->FatInfo.dataStart);
468 if (DeviceExt->FatInfo.FatType == FAT32)
469 {
470 DPRINT("RootCluster: %u\n", DeviceExt->FatInfo.RootCluster);
471 }
472
473 switch (DeviceExt->FatInfo.FatType)
474 {
475 case FAT12:
476 DeviceExt->GetNextCluster = FAT12GetNextCluster;
477 DeviceExt->FindAndMarkAvailableCluster = FAT12FindAndMarkAvailableCluster;
478 DeviceExt->WriteCluster = FAT12WriteCluster;
479 DeviceExt->CleanShutBitMask = 0;
480 break;
481
482 case FAT16:
483 case FATX16:
484 DeviceExt->GetNextCluster = FAT16GetNextCluster;
485 DeviceExt->FindAndMarkAvailableCluster = FAT16FindAndMarkAvailableCluster;
486 DeviceExt->WriteCluster = FAT16WriteCluster;
487 DeviceExt->CleanShutBitMask = 0x8000;
488 break;
489
490 case FAT32:
491 case FATX32:
492 DeviceExt->GetNextCluster = FAT32GetNextCluster;
493 DeviceExt->FindAndMarkAvailableCluster = FAT32FindAndMarkAvailableCluster;
494 DeviceExt->WriteCluster = FAT32WriteCluster;
495 DeviceExt->CleanShutBitMask = 0x80000000;
496 break;
497 }
498
499 if (DeviceExt->FatInfo.FatType == FATX16 ||
500 DeviceExt->FatInfo.FatType == FATX32)
501 {
502 DeviceExt->Flags |= VCB_IS_FATX;
503 DeviceExt->GetNextDirEntry = FATXGetNextDirEntry;
504 DeviceExt->BaseDateYear = 2000;
505 }
506 else
507 {
508 DeviceExt->GetNextDirEntry = FATGetNextDirEntry;
509 DeviceExt->BaseDateYear = 1980;
510 }
511
512 DeviceExt->StorageDevice = DeviceToMount;
513 DeviceExt->StorageDevice->Vpb->DeviceObject = DeviceObject;
514 DeviceExt->StorageDevice->Vpb->RealDevice = DeviceExt->StorageDevice;
515 DeviceExt->StorageDevice->Vpb->Flags |= VPB_MOUNTED;
516 DeviceObject->StackSize = DeviceExt->StorageDevice->StackSize + 1;
517 DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
518
519 DPRINT("FsDeviceObject %p\n", DeviceObject);
520
521 /* Initialize this resource early ... it's used in VfatCleanup */
522 ExInitializeResourceLite(&DeviceExt->DirResource);
523
524 DeviceExt->FATFileObject = IoCreateStreamFileObject(NULL, DeviceExt->StorageDevice);
525 Fcb = vfatNewFCB(DeviceExt, &NameU);
526 if (Fcb == NULL)
527 {
528 Status = STATUS_INSUFFICIENT_RESOURCES;
529 goto ByeBye;
530 }
531
532 Ccb = ExAllocateFromNPagedLookasideList(&VfatGlobalData->CcbLookasideList);
533 if (Ccb == NULL)
534 {
535 Status = STATUS_INSUFFICIENT_RESOURCES;
536 goto ByeBye;
537 }
538
539 RtlZeroMemory(Ccb, sizeof (VFATCCB));
540 DeviceExt->FATFileObject->FsContext = Fcb;
541 DeviceExt->FATFileObject->FsContext2 = Ccb;
542 DeviceExt->FATFileObject->SectionObjectPointer = &Fcb->SectionObjectPointers;
543 DeviceExt->FATFileObject->PrivateCacheMap = NULL;
544 DeviceExt->FATFileObject->Vpb = DeviceObject->Vpb;
545 Fcb->FileObject = DeviceExt->FATFileObject;
546
547 Fcb->Flags |= FCB_IS_FAT;
548
549 Fcb->RFCB.FileSize.QuadPart = DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector;
550 Fcb->RFCB.ValidDataLength = Fcb->RFCB.FileSize;
551 Fcb->RFCB.AllocationSize = Fcb->RFCB.FileSize;
552
553 _SEH2_TRY
554 {
555 CcInitializeCacheMap(DeviceExt->FATFileObject,
556 (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
557 TRUE,
558 &VfatGlobalData->CacheMgrCallbacks,
559 Fcb);
560 }
561 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
562 {
563 Status = _SEH2_GetExceptionCode();
564 goto ByeBye;
565 }
566 _SEH2_END;
567
568 DeviceExt->LastAvailableCluster = 2;
569 ExInitializeResourceLite(&DeviceExt->FatResource);
570
571 InitializeListHead(&DeviceExt->FcbListHead);
572
573 VolumeFcb = vfatNewFCB(DeviceExt, &VolumeNameU);
574 if (VolumeFcb == NULL)
575 {
576 Status = STATUS_INSUFFICIENT_RESOURCES;
577 goto ByeBye;
578 }
579
580 VolumeFcb->Flags = FCB_IS_VOLUME;
581 VolumeFcb->RFCB.FileSize.QuadPart = DeviceExt->FatInfo.Sectors * DeviceExt->FatInfo.BytesPerSector;
582 VolumeFcb->RFCB.ValidDataLength = VolumeFcb->RFCB.FileSize;
583 VolumeFcb->RFCB.AllocationSize = VolumeFcb->RFCB.FileSize;
584 DeviceExt->VolumeFcb = VolumeFcb;
585
586 ExAcquireResourceExclusiveLite(&VfatGlobalData->VolumeListLock, TRUE);
587 InsertHeadList(&VfatGlobalData->VolumeListHead, &DeviceExt->VolumeListEntry);
588 ExReleaseResourceLite(&VfatGlobalData->VolumeListLock);
589
590 /* read serial number */
591 DeviceObject->Vpb->SerialNumber = DeviceExt->FatInfo.VolumeID;
592
593 /* read volume label */
594 ReadVolumeLabel(DeviceExt, DeviceObject->Vpb);
595
596 /* read clean shutdown bit status */
597 Status = GetNextCluster(DeviceExt, 1, &eocMark);
598 if (NT_SUCCESS(Status))
599 {
600 if (eocMark & DeviceExt->CleanShutBitMask)
601 {
602 /* unset clean shutdown bit */
603 eocMark &= ~DeviceExt->CleanShutBitMask;
604 WriteCluster(DeviceExt, 1, eocMark);
605 VolumeFcb->Flags |= VCB_CLEAR_DIRTY;
606 }
607 }
608
609 VolumeFcb->Flags |= VCB_IS_DIRTY;
610
611 FsRtlNotifyVolumeEvent(DeviceExt->FATFileObject, FSRTL_VOLUME_MOUNT);
612 FsRtlNotifyInitializeSync(&DeviceExt->NotifySync);
613 InitializeListHead(&DeviceExt->NotifyList);
614
615 DPRINT("Mount success\n");
616
617 Status = STATUS_SUCCESS;
618
619 ByeBye:
620 if (!NT_SUCCESS(Status))
621 {
622 /* Cleanup */
623 if (DeviceExt && DeviceExt->FATFileObject)
624 ObDereferenceObject (DeviceExt->FATFileObject);
625 if (Fcb)
626 vfatDestroyFCB(Fcb);
627 if (Ccb)
628 vfatDestroyCCB(Ccb);
629 if (DeviceObject)
630 IoDeleteDevice(DeviceObject);
631 }
632
633 return Status;
634 }
635
636
637 /*
638 * FUNCTION: Verify the filesystem
639 */
640 static
641 NTSTATUS
642 VfatVerify(
643 PVFAT_IRP_CONTEXT IrpContext)
644 {
645 PDEVICE_OBJECT DeviceToVerify;
646 NTSTATUS Status = STATUS_SUCCESS;
647 FATINFO FatInfo;
648 BOOLEAN RecognizedFS;
649 PDEVICE_EXTENSION DeviceExt = IrpContext->DeviceExt;
650
651 DPRINT("VfatVerify(IrpContext %p)\n", IrpContext);
652
653 DeviceToVerify = IrpContext->Stack->Parameters.VerifyVolume.DeviceObject;
654 Status = VfatBlockDeviceIoControl(DeviceToVerify,
655 IOCTL_DISK_CHECK_VERIFY,
656 NULL,
657 0,
658 NULL,
659 0,
660 TRUE);
661 DeviceToVerify->Flags &= ~DO_VERIFY_VOLUME;
662 if (!NT_SUCCESS(Status) && Status != STATUS_VERIFY_REQUIRED)
663 {
664 DPRINT("VfatBlockDeviceIoControl() failed (Status %lx)\n", Status);
665 Status = STATUS_WRONG_VOLUME;
666 }
667 else
668 {
669 Status = VfatHasFileSystem(DeviceToVerify, &RecognizedFS, &FatInfo);
670 if (!NT_SUCCESS(Status) || RecognizedFS == FALSE)
671 {
672 Status = STATUS_WRONG_VOLUME;
673 }
674 else if (sizeof(FATINFO) == RtlCompareMemory(&FatInfo, &DeviceExt->FatInfo, sizeof(FATINFO)))
675 {
676 /*
677 * FIXME:
678 * Preformated floppy disks have very often a serial number of 0000:0000.
679 * We should calculate a crc sum over the sectors from the root directory as secondary volume number.
680 * Each write to the root directory must update this crc sum.
681 */
682 }
683 else
684 {
685 Status = STATUS_WRONG_VOLUME;
686 }
687 }
688
689 return Status;
690 }
691
692
693 static
694 NTSTATUS
695 VfatGetVolumeBitmap(
696 PVFAT_IRP_CONTEXT IrpContext)
697 {
698 DPRINT("VfatGetVolumeBitmap (IrpContext %p)\n", IrpContext);
699 return STATUS_INVALID_DEVICE_REQUEST;
700 }
701
702
703 static
704 NTSTATUS
705 VfatGetRetrievalPointers(
706 PVFAT_IRP_CONTEXT IrpContext)
707 {
708 PIO_STACK_LOCATION Stack;
709 LARGE_INTEGER Vcn;
710 PRETRIEVAL_POINTERS_BUFFER RetrievalPointers;
711 PFILE_OBJECT FileObject;
712 ULONG MaxExtentCount;
713 PVFATFCB Fcb;
714 PDEVICE_EXTENSION DeviceExt;
715 ULONG FirstCluster;
716 ULONG CurrentCluster;
717 ULONG LastCluster;
718 NTSTATUS Status;
719
720 DPRINT("VfatGetRetrievalPointers(IrpContext %p)\n", IrpContext);
721
722 DeviceExt = IrpContext->DeviceExt;
723 FileObject = IrpContext->FileObject;
724 Stack = IrpContext->Stack;
725 if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STARTING_VCN_INPUT_BUFFER) ||
726 Stack->Parameters.DeviceIoControl.Type3InputBuffer == NULL)
727 {
728 return STATUS_INVALID_PARAMETER;
729 }
730
731 if (IrpContext->Irp->UserBuffer == NULL ||
732 Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(RETRIEVAL_POINTERS_BUFFER))
733 {
734 return STATUS_BUFFER_TOO_SMALL;
735 }
736
737 Fcb = FileObject->FsContext;
738
739 ExAcquireResourceSharedLite(&Fcb->MainResource, TRUE);
740
741 Vcn = ((PSTARTING_VCN_INPUT_BUFFER)Stack->Parameters.DeviceIoControl.Type3InputBuffer)->StartingVcn;
742 RetrievalPointers = IrpContext->Irp->UserBuffer;
743
744 MaxExtentCount = ((Stack->Parameters.DeviceIoControl.OutputBufferLength - sizeof(RetrievalPointers->ExtentCount) - sizeof(RetrievalPointers->StartingVcn)) / sizeof(RetrievalPointers->Extents[0]));
745
746 if (Vcn.QuadPart >= Fcb->RFCB.AllocationSize.QuadPart / DeviceExt->FatInfo.BytesPerCluster)
747 {
748 Status = STATUS_INVALID_PARAMETER;
749 goto ByeBye;
750 }
751
752 CurrentCluster = FirstCluster = vfatDirEntryGetFirstCluster(DeviceExt, &Fcb->entry);
753 Status = OffsetToCluster(DeviceExt, FirstCluster,
754 Vcn.u.LowPart * DeviceExt->FatInfo.BytesPerCluster,
755 &CurrentCluster, FALSE);
756 if (!NT_SUCCESS(Status))
757 {
758 goto ByeBye;
759 }
760
761 RetrievalPointers->StartingVcn = Vcn;
762 RetrievalPointers->ExtentCount = 0;
763 RetrievalPointers->Extents[0].Lcn.u.HighPart = 0;
764 RetrievalPointers->Extents[0].Lcn.u.LowPart = CurrentCluster - 2;
765 LastCluster = 0;
766 while (CurrentCluster != 0xffffffff && RetrievalPointers->ExtentCount < MaxExtentCount)
767 {
768 LastCluster = CurrentCluster;
769 Status = NextCluster(DeviceExt, CurrentCluster, &CurrentCluster, FALSE);
770 Vcn.QuadPart++;
771 if (!NT_SUCCESS(Status))
772 {
773 goto ByeBye;
774 }
775
776 if (LastCluster + 1 != CurrentCluster)
777 {
778 RetrievalPointers->Extents[RetrievalPointers->ExtentCount].NextVcn = Vcn;
779 RetrievalPointers->ExtentCount++;
780 if (RetrievalPointers->ExtentCount < MaxExtentCount)
781 {
782 RetrievalPointers->Extents[RetrievalPointers->ExtentCount].Lcn.u.HighPart = 0;
783 RetrievalPointers->Extents[RetrievalPointers->ExtentCount].Lcn.u.LowPart = CurrentCluster - 2;
784 }
785 }
786 }
787
788 IrpContext->Irp->IoStatus.Information = sizeof(RETRIEVAL_POINTERS_BUFFER) + (sizeof(RetrievalPointers->Extents[0]) * (RetrievalPointers->ExtentCount - 1));
789 Status = STATUS_SUCCESS;
790
791 ByeBye:
792 ExReleaseResourceLite(&Fcb->MainResource);
793
794 return Status;
795 }
796
797 static
798 NTSTATUS
799 VfatMoveFile(
800 PVFAT_IRP_CONTEXT IrpContext)
801 {
802 DPRINT("VfatMoveFile(IrpContext %p)\n", IrpContext);
803 return STATUS_INVALID_DEVICE_REQUEST;
804 }
805
806 static
807 NTSTATUS
808 VfatIsVolumeDirty(
809 PVFAT_IRP_CONTEXT IrpContext)
810 {
811 PULONG Flags;
812
813 DPRINT("VfatIsVolumeDirty(IrpContext %p)\n", IrpContext);
814
815 if (IrpContext->Stack->Parameters.FileSystemControl.OutputBufferLength != sizeof(ULONG))
816 return STATUS_INVALID_BUFFER_SIZE;
817 else if (!IrpContext->Irp->AssociatedIrp.SystemBuffer)
818 return STATUS_INVALID_USER_BUFFER;
819
820 Flags = (PULONG)IrpContext->Irp->AssociatedIrp.SystemBuffer;
821 *Flags = 0;
822
823 if ((IrpContext->DeviceExt->VolumeFcb->Flags & VCB_IS_DIRTY) &&
824 !(IrpContext->DeviceExt->VolumeFcb->Flags & VCB_CLEAR_DIRTY))
825 {
826 *Flags |= VOLUME_IS_DIRTY;
827 }
828
829 return STATUS_SUCCESS;
830 }
831
832 static
833 NTSTATUS
834 VfatMarkVolumeDirty(
835 PVFAT_IRP_CONTEXT IrpContext)
836 {
837 ULONG eocMark;
838 PDEVICE_EXTENSION DeviceExt;
839 NTSTATUS Status = STATUS_SUCCESS;
840
841 DPRINT("VfatMarkVolumeDirty(IrpContext %p)\n", IrpContext);
842 DeviceExt = IrpContext->DeviceExt;
843
844 if (!(DeviceExt->VolumeFcb->Flags & VCB_IS_DIRTY))
845 {
846 Status = GetNextCluster(DeviceExt, 1, &eocMark);
847 if (NT_SUCCESS(Status))
848 {
849 /* unset clean shutdown bit */
850 eocMark &= ~DeviceExt->CleanShutBitMask;
851 Status = WriteCluster(DeviceExt, 1, eocMark);
852 }
853 }
854
855 DeviceExt->VolumeFcb->Flags &= ~VCB_CLEAR_DIRTY;
856
857 return Status;
858 }
859
860 static
861 NTSTATUS
862 VfatLockOrUnlockVolume(
863 PVFAT_IRP_CONTEXT IrpContext,
864 BOOLEAN Lock)
865 {
866 PFILE_OBJECT FileObject;
867 PDEVICE_EXTENSION DeviceExt;
868 PVFATFCB Fcb;
869
870 DPRINT("VfatLockOrUnlockVolume(%p, %d)\n", IrpContext, Lock);
871
872 DeviceExt = IrpContext->DeviceExt;
873 FileObject = IrpContext->FileObject;
874 Fcb = FileObject->FsContext;
875
876 /* Only allow locking with the volume open */
877 if (!(Fcb->Flags & FCB_IS_VOLUME))
878 {
879 return STATUS_ACCESS_DENIED;
880 }
881
882 /* Bail out if it's already in the demanded state */
883 if (((DeviceExt->Flags & VCB_VOLUME_LOCKED) && Lock) ||
884 (!(DeviceExt->Flags & VCB_VOLUME_LOCKED) && !Lock))
885 {
886 return STATUS_ACCESS_DENIED;
887 }
888
889 /* Deny locking if we're not alone */
890 if (Lock && DeviceExt->OpenHandleCount != 1)
891 {
892 return STATUS_ACCESS_DENIED;
893 }
894
895 /* Finally, proceed */
896 if (Lock)
897 {
898 DeviceExt->Flags |= VCB_VOLUME_LOCKED;
899 }
900 else
901 {
902 DeviceExt->Flags &= ~VCB_VOLUME_LOCKED;
903 }
904
905 return STATUS_SUCCESS;
906 }
907
908 static
909 NTSTATUS
910 VfatDismountVolume(
911 PVFAT_IRP_CONTEXT IrpContext)
912 {
913 PDEVICE_EXTENSION DeviceExt;
914 PLIST_ENTRY NextEntry;
915 PVFATFCB Fcb;
916
917 DPRINT("VfatDismountVolume(%p)\n", IrpContext);
918
919 DeviceExt = IrpContext->DeviceExt;
920
921 /* We HAVE to be locked. Windows also allows dismount with no lock
922 * but we're here mainly for 1st stage, so KISS
923 */
924 if (!(DeviceExt->Flags & VCB_VOLUME_LOCKED))
925 {
926 return STATUS_ACCESS_DENIED;
927 }
928
929 /* Race condition? */
930 if (DeviceExt->Flags & VCB_DISMOUNT_PENDING)
931 {
932 return STATUS_VOLUME_DISMOUNTED;
933 }
934
935 /* Notify we'll dismount. Pass that point there's no reason we fail */
936 FsRtlNotifyVolumeEvent(IrpContext->Stack->FileObject, FSRTL_VOLUME_DISMOUNT);
937
938 ExAcquireResourceExclusiveLite(&DeviceExt->FatResource, TRUE);
939
940 /* Browse all the available FCBs first, and force data writing to disk */
941 for (NextEntry = DeviceExt->FcbListHead.Flink;
942 NextEntry != &DeviceExt->FcbListHead;
943 NextEntry = NextEntry->Flink)
944 {
945 Fcb = CONTAINING_RECORD(NextEntry, VFATFCB, FcbListEntry);
946
947 ExAcquireResourceExclusiveLite(&Fcb->MainResource, TRUE);
948 ExAcquireResourceExclusiveLite(&Fcb->PagingIoResource, TRUE);
949
950 if (Fcb->FileObject)
951 {
952 if (Fcb->Flags & FCB_IS_DIRTY)
953 {
954 VfatUpdateEntry(Fcb);
955 }
956
957 CcPurgeCacheSection(Fcb->FileObject->SectionObjectPointer, NULL, 0, FALSE);
958 CcUninitializeCacheMap(Fcb->FileObject, &Fcb->RFCB.FileSize, NULL);
959 }
960
961 ExReleaseResourceLite(&Fcb->PagingIoResource);
962 ExReleaseResourceLite(&Fcb->MainResource);
963 }
964
965 /* Rebrowse the FCB in order to free them now */
966 while (!IsListEmpty(&DeviceExt->FcbListHead))
967 {
968 NextEntry = RemoveHeadList(&DeviceExt->FcbListHead);
969 Fcb = CONTAINING_RECORD(NextEntry, VFATFCB, FcbListEntry);
970 vfatDestroyFCB(Fcb);
971 }
972
973 /* Mark we're being dismounted */
974 DeviceExt->Flags |= VCB_DISMOUNT_PENDING;
975 IrpContext->DeviceObject->Vpb->Flags &= ~VPB_MOUNTED;
976
977 ExReleaseResourceLite(&DeviceExt->FatResource);
978
979 /* Release a few resources and quit, we're done */
980 ExDeleteResourceLite(&DeviceExt->DirResource);
981 ExDeleteResourceLite(&DeviceExt->FatResource);
982 ObDereferenceObject(DeviceExt->FATFileObject);
983
984 return STATUS_SUCCESS;
985 }
986
987 /*
988 * FUNCTION: File system control
989 */
990 NTSTATUS
991 VfatFileSystemControl(
992 PVFAT_IRP_CONTEXT IrpContext)
993 {
994 NTSTATUS Status;
995
996 DPRINT("VfatFileSystemControl(IrpContext %p)\n", IrpContext);
997
998 ASSERT(IrpContext);
999 ASSERT(IrpContext->Irp);
1000 ASSERT(IrpContext->Stack);
1001
1002 IrpContext->Irp->IoStatus.Information = 0;
1003
1004 switch (IrpContext->MinorFunction)
1005 {
1006 case IRP_MN_KERNEL_CALL:
1007 case IRP_MN_USER_FS_REQUEST:
1008 switch(IrpContext->Stack->Parameters.DeviceIoControl.IoControlCode)
1009 {
1010 case FSCTL_GET_VOLUME_BITMAP:
1011 Status = VfatGetVolumeBitmap(IrpContext);
1012 break;
1013
1014 case FSCTL_GET_RETRIEVAL_POINTERS:
1015 Status = VfatGetRetrievalPointers(IrpContext);
1016 break;
1017
1018 case FSCTL_MOVE_FILE:
1019 Status = VfatMoveFile(IrpContext);
1020 break;
1021
1022 case FSCTL_IS_VOLUME_DIRTY:
1023 Status = VfatIsVolumeDirty(IrpContext);
1024 break;
1025
1026 case FSCTL_MARK_VOLUME_DIRTY:
1027 Status = VfatMarkVolumeDirty(IrpContext);
1028 break;
1029
1030 case FSCTL_LOCK_VOLUME:
1031 Status = VfatLockOrUnlockVolume(IrpContext, TRUE);
1032 break;
1033
1034 case FSCTL_UNLOCK_VOLUME:
1035 Status = VfatLockOrUnlockVolume(IrpContext, FALSE);
1036 break;
1037
1038 case FSCTL_DISMOUNT_VOLUME:
1039 Status = VfatDismountVolume(IrpContext);
1040 break;
1041
1042 default:
1043 Status = STATUS_INVALID_DEVICE_REQUEST;
1044 }
1045 break;
1046
1047 case IRP_MN_MOUNT_VOLUME:
1048 Status = VfatMount(IrpContext);
1049 break;
1050
1051 case IRP_MN_VERIFY_VOLUME:
1052 DPRINT("VFATFS: IRP_MN_VERIFY_VOLUME\n");
1053 Status = VfatVerify(IrpContext);
1054 break;
1055
1056 default:
1057 DPRINT("VFAT FSC: MinorFunction %u\n", IrpContext->MinorFunction);
1058 Status = STATUS_INVALID_DEVICE_REQUEST;
1059 break;
1060 }
1061
1062 IrpContext->Irp->IoStatus.Status = Status;
1063
1064 IoCompleteRequest(IrpContext->Irp, IO_NO_INCREMENT);
1065 VfatFreeIrpContext(IrpContext);
1066 return Status;
1067 }