[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->IoVPB = DeviceObject->Vpb;
525 DeviceExt->SpareVPB = ExAllocatePoolWithTag(NonPagedPool, sizeof(VPB), TAG_VFAT);
526 if (DeviceExt->SpareVPB == NULL)
527 {
528 Status = STATUS_INSUFFICIENT_RESOURCES;
529 goto ByeBye;
530 }
531
532 DeviceExt->FATFileObject = IoCreateStreamFileObject(NULL, DeviceExt->StorageDevice);
533 Fcb = vfatNewFCB(DeviceExt, &NameU);
534 if (Fcb == NULL)
535 {
536 Status = STATUS_INSUFFICIENT_RESOURCES;
537 goto ByeBye;
538 }
539
540 Ccb = ExAllocateFromNPagedLookasideList(&VfatGlobalData->CcbLookasideList);
541 if (Ccb == NULL)
542 {
543 Status = STATUS_INSUFFICIENT_RESOURCES;
544 goto ByeBye;
545 }
546
547 RtlZeroMemory(Ccb, sizeof (VFATCCB));
548 DeviceExt->FATFileObject->FsContext = Fcb;
549 DeviceExt->FATFileObject->FsContext2 = Ccb;
550 DeviceExt->FATFileObject->SectionObjectPointer = &Fcb->SectionObjectPointers;
551 DeviceExt->FATFileObject->PrivateCacheMap = NULL;
552 DeviceExt->FATFileObject->Vpb = DeviceObject->Vpb;
553 Fcb->FileObject = DeviceExt->FATFileObject;
554
555 Fcb->Flags |= FCB_IS_FAT;
556
557 Fcb->RFCB.FileSize.QuadPart = DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector;
558 Fcb->RFCB.ValidDataLength = Fcb->RFCB.FileSize;
559 Fcb->RFCB.AllocationSize = Fcb->RFCB.FileSize;
560
561 _SEH2_TRY
562 {
563 CcInitializeCacheMap(DeviceExt->FATFileObject,
564 (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
565 TRUE,
566 &VfatGlobalData->CacheMgrCallbacks,
567 Fcb);
568 }
569 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
570 {
571 Status = _SEH2_GetExceptionCode();
572 goto ByeBye;
573 }
574 _SEH2_END;
575
576 DeviceExt->LastAvailableCluster = 2;
577 ExInitializeResourceLite(&DeviceExt->FatResource);
578
579 InitializeListHead(&DeviceExt->FcbListHead);
580
581 VolumeFcb = vfatNewFCB(DeviceExt, &VolumeNameU);
582 if (VolumeFcb == NULL)
583 {
584 Status = STATUS_INSUFFICIENT_RESOURCES;
585 goto ByeBye;
586 }
587
588 VolumeFcb->Flags = FCB_IS_VOLUME;
589 VolumeFcb->RFCB.FileSize.QuadPart = DeviceExt->FatInfo.Sectors * DeviceExt->FatInfo.BytesPerSector;
590 VolumeFcb->RFCB.ValidDataLength = VolumeFcb->RFCB.FileSize;
591 VolumeFcb->RFCB.AllocationSize = VolumeFcb->RFCB.FileSize;
592 DeviceExt->VolumeFcb = VolumeFcb;
593
594 ExAcquireResourceExclusiveLite(&VfatGlobalData->VolumeListLock, TRUE);
595 InsertHeadList(&VfatGlobalData->VolumeListHead, &DeviceExt->VolumeListEntry);
596 ExReleaseResourceLite(&VfatGlobalData->VolumeListLock);
597
598 /* read serial number */
599 DeviceObject->Vpb->SerialNumber = DeviceExt->FatInfo.VolumeID;
600
601 /* read volume label */
602 ReadVolumeLabel(DeviceExt, DeviceObject->Vpb);
603
604 /* read clean shutdown bit status */
605 Status = GetNextCluster(DeviceExt, 1, &eocMark);
606 if (NT_SUCCESS(Status))
607 {
608 if (eocMark & DeviceExt->CleanShutBitMask)
609 {
610 /* unset clean shutdown bit */
611 eocMark &= ~DeviceExt->CleanShutBitMask;
612 WriteCluster(DeviceExt, 1, eocMark);
613 VolumeFcb->Flags |= VCB_CLEAR_DIRTY;
614 }
615 }
616
617 VolumeFcb->Flags |= VCB_IS_DIRTY;
618
619 FsRtlNotifyVolumeEvent(DeviceExt->FATFileObject, FSRTL_VOLUME_MOUNT);
620 FsRtlNotifyInitializeSync(&DeviceExt->NotifySync);
621 InitializeListHead(&DeviceExt->NotifyList);
622
623 DPRINT("Mount success\n");
624
625 Status = STATUS_SUCCESS;
626
627 ByeBye:
628 if (!NT_SUCCESS(Status))
629 {
630 /* Cleanup */
631 if (DeviceExt && DeviceExt->FATFileObject)
632 ObDereferenceObject (DeviceExt->FATFileObject);
633 if (DeviceExt && DeviceExt->SpareVPB)
634 ExFreePoolWithTag(DeviceExt->SpareVPB, TAG_VFAT);
635 if (Fcb)
636 vfatDestroyFCB(Fcb);
637 if (Ccb)
638 vfatDestroyCCB(Ccb);
639 if (DeviceObject)
640 IoDeleteDevice(DeviceObject);
641 }
642
643 return Status;
644 }
645
646
647 /*
648 * FUNCTION: Verify the filesystem
649 */
650 static
651 NTSTATUS
652 VfatVerify(
653 PVFAT_IRP_CONTEXT IrpContext)
654 {
655 PDEVICE_OBJECT DeviceToVerify;
656 NTSTATUS Status = STATUS_SUCCESS;
657 FATINFO FatInfo;
658 BOOLEAN RecognizedFS;
659 PDEVICE_EXTENSION DeviceExt = IrpContext->DeviceExt;
660
661 DPRINT("VfatVerify(IrpContext %p)\n", IrpContext);
662
663 DeviceToVerify = IrpContext->Stack->Parameters.VerifyVolume.DeviceObject;
664 Status = VfatBlockDeviceIoControl(DeviceToVerify,
665 IOCTL_DISK_CHECK_VERIFY,
666 NULL,
667 0,
668 NULL,
669 0,
670 TRUE);
671 DeviceToVerify->Flags &= ~DO_VERIFY_VOLUME;
672 if (!NT_SUCCESS(Status) && Status != STATUS_VERIFY_REQUIRED)
673 {
674 DPRINT("VfatBlockDeviceIoControl() failed (Status %lx)\n", Status);
675 Status = STATUS_WRONG_VOLUME;
676 }
677 else
678 {
679 Status = VfatHasFileSystem(DeviceToVerify, &RecognizedFS, &FatInfo);
680 if (!NT_SUCCESS(Status) || RecognizedFS == FALSE)
681 {
682 Status = STATUS_WRONG_VOLUME;
683 }
684 else if (sizeof(FATINFO) == RtlCompareMemory(&FatInfo, &DeviceExt->FatInfo, sizeof(FATINFO)))
685 {
686 /*
687 * FIXME:
688 * Preformated floppy disks have very often a serial number of 0000:0000.
689 * We should calculate a crc sum over the sectors from the root directory as secondary volume number.
690 * Each write to the root directory must update this crc sum.
691 */
692 }
693 else
694 {
695 Status = STATUS_WRONG_VOLUME;
696 }
697 }
698
699 return Status;
700 }
701
702
703 static
704 NTSTATUS
705 VfatGetVolumeBitmap(
706 PVFAT_IRP_CONTEXT IrpContext)
707 {
708 DPRINT("VfatGetVolumeBitmap (IrpContext %p)\n", IrpContext);
709 return STATUS_INVALID_DEVICE_REQUEST;
710 }
711
712
713 static
714 NTSTATUS
715 VfatGetRetrievalPointers(
716 PVFAT_IRP_CONTEXT IrpContext)
717 {
718 PIO_STACK_LOCATION Stack;
719 LARGE_INTEGER Vcn;
720 PRETRIEVAL_POINTERS_BUFFER RetrievalPointers;
721 PFILE_OBJECT FileObject;
722 ULONG MaxExtentCount;
723 PVFATFCB Fcb;
724 PDEVICE_EXTENSION DeviceExt;
725 ULONG FirstCluster;
726 ULONG CurrentCluster;
727 ULONG LastCluster;
728 NTSTATUS Status;
729
730 DPRINT("VfatGetRetrievalPointers(IrpContext %p)\n", IrpContext);
731
732 DeviceExt = IrpContext->DeviceExt;
733 FileObject = IrpContext->FileObject;
734 Stack = IrpContext->Stack;
735 if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STARTING_VCN_INPUT_BUFFER) ||
736 Stack->Parameters.DeviceIoControl.Type3InputBuffer == NULL)
737 {
738 return STATUS_INVALID_PARAMETER;
739 }
740
741 if (IrpContext->Irp->UserBuffer == NULL ||
742 Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(RETRIEVAL_POINTERS_BUFFER))
743 {
744 return STATUS_BUFFER_TOO_SMALL;
745 }
746
747 Fcb = FileObject->FsContext;
748
749 ExAcquireResourceSharedLite(&Fcb->MainResource, TRUE);
750
751 Vcn = ((PSTARTING_VCN_INPUT_BUFFER)Stack->Parameters.DeviceIoControl.Type3InputBuffer)->StartingVcn;
752 RetrievalPointers = IrpContext->Irp->UserBuffer;
753
754 MaxExtentCount = ((Stack->Parameters.DeviceIoControl.OutputBufferLength - sizeof(RetrievalPointers->ExtentCount) - sizeof(RetrievalPointers->StartingVcn)) / sizeof(RetrievalPointers->Extents[0]));
755
756 if (Vcn.QuadPart >= Fcb->RFCB.AllocationSize.QuadPart / DeviceExt->FatInfo.BytesPerCluster)
757 {
758 Status = STATUS_INVALID_PARAMETER;
759 goto ByeBye;
760 }
761
762 CurrentCluster = FirstCluster = vfatDirEntryGetFirstCluster(DeviceExt, &Fcb->entry);
763 Status = OffsetToCluster(DeviceExt, FirstCluster,
764 Vcn.u.LowPart * DeviceExt->FatInfo.BytesPerCluster,
765 &CurrentCluster, FALSE);
766 if (!NT_SUCCESS(Status))
767 {
768 goto ByeBye;
769 }
770
771 RetrievalPointers->StartingVcn = Vcn;
772 RetrievalPointers->ExtentCount = 0;
773 RetrievalPointers->Extents[0].Lcn.u.HighPart = 0;
774 RetrievalPointers->Extents[0].Lcn.u.LowPart = CurrentCluster - 2;
775 LastCluster = 0;
776 while (CurrentCluster != 0xffffffff && RetrievalPointers->ExtentCount < MaxExtentCount)
777 {
778 LastCluster = CurrentCluster;
779 Status = NextCluster(DeviceExt, CurrentCluster, &CurrentCluster, FALSE);
780 Vcn.QuadPart++;
781 if (!NT_SUCCESS(Status))
782 {
783 goto ByeBye;
784 }
785
786 if (LastCluster + 1 != CurrentCluster)
787 {
788 RetrievalPointers->Extents[RetrievalPointers->ExtentCount].NextVcn = Vcn;
789 RetrievalPointers->ExtentCount++;
790 if (RetrievalPointers->ExtentCount < MaxExtentCount)
791 {
792 RetrievalPointers->Extents[RetrievalPointers->ExtentCount].Lcn.u.HighPart = 0;
793 RetrievalPointers->Extents[RetrievalPointers->ExtentCount].Lcn.u.LowPart = CurrentCluster - 2;
794 }
795 }
796 }
797
798 IrpContext->Irp->IoStatus.Information = sizeof(RETRIEVAL_POINTERS_BUFFER) + (sizeof(RetrievalPointers->Extents[0]) * (RetrievalPointers->ExtentCount - 1));
799 Status = STATUS_SUCCESS;
800
801 ByeBye:
802 ExReleaseResourceLite(&Fcb->MainResource);
803
804 return Status;
805 }
806
807 static
808 NTSTATUS
809 VfatMoveFile(
810 PVFAT_IRP_CONTEXT IrpContext)
811 {
812 DPRINT("VfatMoveFile(IrpContext %p)\n", IrpContext);
813 return STATUS_INVALID_DEVICE_REQUEST;
814 }
815
816 static
817 NTSTATUS
818 VfatIsVolumeDirty(
819 PVFAT_IRP_CONTEXT IrpContext)
820 {
821 PULONG Flags;
822
823 DPRINT("VfatIsVolumeDirty(IrpContext %p)\n", IrpContext);
824
825 if (IrpContext->Stack->Parameters.FileSystemControl.OutputBufferLength != sizeof(ULONG))
826 return STATUS_INVALID_BUFFER_SIZE;
827 else if (!IrpContext->Irp->AssociatedIrp.SystemBuffer)
828 return STATUS_INVALID_USER_BUFFER;
829
830 Flags = (PULONG)IrpContext->Irp->AssociatedIrp.SystemBuffer;
831 *Flags = 0;
832
833 if ((IrpContext->DeviceExt->VolumeFcb->Flags & VCB_IS_DIRTY) &&
834 !(IrpContext->DeviceExt->VolumeFcb->Flags & VCB_CLEAR_DIRTY))
835 {
836 *Flags |= VOLUME_IS_DIRTY;
837 }
838
839 return STATUS_SUCCESS;
840 }
841
842 static
843 NTSTATUS
844 VfatMarkVolumeDirty(
845 PVFAT_IRP_CONTEXT IrpContext)
846 {
847 ULONG eocMark;
848 PDEVICE_EXTENSION DeviceExt;
849 NTSTATUS Status = STATUS_SUCCESS;
850
851 DPRINT("VfatMarkVolumeDirty(IrpContext %p)\n", IrpContext);
852 DeviceExt = IrpContext->DeviceExt;
853
854 if (!(DeviceExt->VolumeFcb->Flags & VCB_IS_DIRTY))
855 {
856 Status = GetNextCluster(DeviceExt, 1, &eocMark);
857 if (NT_SUCCESS(Status))
858 {
859 /* unset clean shutdown bit */
860 eocMark &= ~DeviceExt->CleanShutBitMask;
861 Status = WriteCluster(DeviceExt, 1, eocMark);
862 }
863 }
864
865 DeviceExt->VolumeFcb->Flags &= ~VCB_CLEAR_DIRTY;
866
867 return Status;
868 }
869
870 static
871 NTSTATUS
872 VfatLockOrUnlockVolume(
873 PVFAT_IRP_CONTEXT IrpContext,
874 BOOLEAN Lock)
875 {
876 PFILE_OBJECT FileObject;
877 PDEVICE_EXTENSION DeviceExt;
878 PVFATFCB Fcb;
879
880 DPRINT("VfatLockOrUnlockVolume(%p, %d)\n", IrpContext, Lock);
881
882 DeviceExt = IrpContext->DeviceExt;
883 FileObject = IrpContext->FileObject;
884 Fcb = FileObject->FsContext;
885
886 /* Only allow locking with the volume open */
887 if (!(Fcb->Flags & FCB_IS_VOLUME))
888 {
889 return STATUS_ACCESS_DENIED;
890 }
891
892 /* Bail out if it's already in the demanded state */
893 if (((DeviceExt->Flags & VCB_VOLUME_LOCKED) && Lock) ||
894 (!(DeviceExt->Flags & VCB_VOLUME_LOCKED) && !Lock))
895 {
896 return STATUS_ACCESS_DENIED;
897 }
898
899 /* Deny locking if we're not alone */
900 if (Lock && DeviceExt->OpenHandleCount != 1)
901 {
902 return STATUS_ACCESS_DENIED;
903 }
904
905 /* Finally, proceed */
906 if (Lock)
907 {
908 DeviceExt->Flags |= VCB_VOLUME_LOCKED;
909 }
910 else
911 {
912 DeviceExt->Flags &= ~VCB_VOLUME_LOCKED;
913 }
914
915 return STATUS_SUCCESS;
916 }
917
918 static
919 NTSTATUS
920 VfatDismountVolume(
921 PVFAT_IRP_CONTEXT IrpContext)
922 {
923 PDEVICE_EXTENSION DeviceExt;
924 PLIST_ENTRY NextEntry;
925 PVFATFCB Fcb;
926 PFILE_OBJECT FileObject;
927
928 DPRINT("VfatDismountVolume(%p)\n", IrpContext);
929
930 DeviceExt = IrpContext->DeviceExt;
931 FileObject = IrpContext->FileObject;
932
933 /* We HAVE to be locked. Windows also allows dismount with no lock
934 * but we're here mainly for 1st stage, so KISS
935 */
936 if (!(DeviceExt->Flags & VCB_VOLUME_LOCKED))
937 {
938 return STATUS_ACCESS_DENIED;
939 }
940
941 /* Race condition? */
942 if (DeviceExt->Flags & VCB_DISMOUNT_PENDING)
943 {
944 return STATUS_VOLUME_DISMOUNTED;
945 }
946
947 /* Notify we'll dismount. Pass that point there's no reason we fail */
948 FsRtlNotifyVolumeEvent(IrpContext->Stack->FileObject, FSRTL_VOLUME_DISMOUNT);
949
950 ExAcquireResourceExclusiveLite(&DeviceExt->FatResource, TRUE);
951
952 /* Flush volume & files */
953 VfatFlushVolume(DeviceExt, (PVFATFCB)FileObject->FsContext);
954
955 /* Rebrowse the FCB in order to free them now */
956 while (!IsListEmpty(&DeviceExt->FcbListHead))
957 {
958 NextEntry = RemoveHeadList(&DeviceExt->FcbListHead);
959 Fcb = CONTAINING_RECORD(NextEntry, VFATFCB, FcbListEntry);
960 vfatDestroyFCB(Fcb);
961 }
962
963 /* Mark we're being dismounted */
964 DeviceExt->Flags |= VCB_DISMOUNT_PENDING;
965 IrpContext->DeviceObject->Vpb->Flags &= ~VPB_MOUNTED;
966
967 ExReleaseResourceLite(&DeviceExt->FatResource);
968
969 /* Release a few resources and quit, we're done */
970 ExDeleteResourceLite(&DeviceExt->DirResource);
971 ExDeleteResourceLite(&DeviceExt->FatResource);
972 ObDereferenceObject(DeviceExt->FATFileObject);
973
974 return STATUS_SUCCESS;
975 }
976
977 /*
978 * FUNCTION: File system control
979 */
980 NTSTATUS
981 VfatFileSystemControl(
982 PVFAT_IRP_CONTEXT IrpContext)
983 {
984 NTSTATUS Status;
985
986 DPRINT("VfatFileSystemControl(IrpContext %p)\n", IrpContext);
987
988 ASSERT(IrpContext);
989 ASSERT(IrpContext->Irp);
990 ASSERT(IrpContext->Stack);
991
992 IrpContext->Irp->IoStatus.Information = 0;
993
994 switch (IrpContext->MinorFunction)
995 {
996 case IRP_MN_KERNEL_CALL:
997 case IRP_MN_USER_FS_REQUEST:
998 switch(IrpContext->Stack->Parameters.DeviceIoControl.IoControlCode)
999 {
1000 case FSCTL_GET_VOLUME_BITMAP:
1001 Status = VfatGetVolumeBitmap(IrpContext);
1002 break;
1003
1004 case FSCTL_GET_RETRIEVAL_POINTERS:
1005 Status = VfatGetRetrievalPointers(IrpContext);
1006 break;
1007
1008 case FSCTL_MOVE_FILE:
1009 Status = VfatMoveFile(IrpContext);
1010 break;
1011
1012 case FSCTL_IS_VOLUME_DIRTY:
1013 Status = VfatIsVolumeDirty(IrpContext);
1014 break;
1015
1016 case FSCTL_MARK_VOLUME_DIRTY:
1017 Status = VfatMarkVolumeDirty(IrpContext);
1018 break;
1019
1020 case FSCTL_LOCK_VOLUME:
1021 Status = VfatLockOrUnlockVolume(IrpContext, TRUE);
1022 break;
1023
1024 case FSCTL_UNLOCK_VOLUME:
1025 Status = VfatLockOrUnlockVolume(IrpContext, FALSE);
1026 break;
1027
1028 case FSCTL_DISMOUNT_VOLUME:
1029 Status = VfatDismountVolume(IrpContext);
1030 break;
1031
1032 default:
1033 Status = STATUS_INVALID_DEVICE_REQUEST;
1034 }
1035 break;
1036
1037 case IRP_MN_MOUNT_VOLUME:
1038 Status = VfatMount(IrpContext);
1039 break;
1040
1041 case IRP_MN_VERIFY_VOLUME:
1042 DPRINT("VFATFS: IRP_MN_VERIFY_VOLUME\n");
1043 Status = VfatVerify(IrpContext);
1044 break;
1045
1046 default:
1047 DPRINT("VFAT FSC: MinorFunction %u\n", IrpContext->MinorFunction);
1048 Status = STATUS_INVALID_DEVICE_REQUEST;
1049 break;
1050 }
1051
1052 IrpContext->Irp->IoStatus.Status = Status;
1053
1054 IoCompleteRequest(IrpContext->Irp, IO_NO_INCREMENT);
1055 VfatFreeIrpContext(IrpContext);
1056 return Status;
1057 }