938467b5b3ada24643b3f38c620588633e84d333
[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 PartitionInfoIsValid = TRUE;
93 DPRINT("Partition Information:\n");
94 DPRINT("StartingOffset %I64x\n", PartitionInfo.StartingOffset.QuadPart / 512);
95 DPRINT("PartitionLength %I64x\n", PartitionInfo.PartitionLength.QuadPart / 512);
96 DPRINT("HiddenSectors %u\n", PartitionInfo.HiddenSectors);
97 DPRINT("PartitionNumber %u\n", PartitionInfo.PartitionNumber);
98 DPRINT("PartitionType %u\n", PartitionInfo.PartitionType);
99 DPRINT("BootIndicator %u\n", PartitionInfo.BootIndicator);
100 DPRINT("RecognizedPartition %u\n", PartitionInfo.RecognizedPartition);
101 DPRINT("RewritePartition %u\n", PartitionInfo.RewritePartition);
102 if (PartitionInfo.PartitionType)
103 {
104 if (PartitionInfo.PartitionType == PARTITION_FAT_12 ||
105 PartitionInfo.PartitionType == PARTITION_FAT_16 ||
106 PartitionInfo.PartitionType == PARTITION_HUGE ||
107 PartitionInfo.PartitionType == PARTITION_FAT32 ||
108 PartitionInfo.PartitionType == PARTITION_FAT32_XINT13 ||
109 PartitionInfo.PartitionType == PARTITION_XINT13)
110 {
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 *RecognizedFS = TRUE;
121 }
122 }
123 else if (DiskGeometry.MediaType == Unknown)
124 {
125 /*
126 * Floppy disk driver can return Unknown as media type if it
127 * doesn't know yet what floppy in the drive really is. This is
128 * perfectly correct to do under Windows.
129 */
130 *RecognizedFS = TRUE;
131 DiskGeometry.BytesPerSector = 512;
132 }
133 else
134 {
135 *RecognizedFS = TRUE;
136 }
137
138 if (*RecognizedFS)
139 {
140 Boot = ExAllocatePoolWithTag(NonPagedPool, DiskGeometry.BytesPerSector, TAG_VFAT);
141 if (Boot == NULL)
142 {
143 return STATUS_INSUFFICIENT_RESOURCES;
144 }
145
146 Offset.QuadPart = 0;
147
148 /* Try to recognize FAT12/FAT16/FAT32 partitions */
149 Status = VfatReadDisk(DeviceToMount, &Offset, DiskGeometry.BytesPerSector, (PUCHAR) Boot, FALSE);
150 if (NT_SUCCESS(Status))
151 {
152 if (Boot->Signatur1 != 0xaa55)
153 {
154 *RecognizedFS = FALSE;
155 }
156
157 if (*RecognizedFS &&
158 Boot->BytesPerSector != 512 &&
159 Boot->BytesPerSector != 1024 &&
160 Boot->BytesPerSector != 2048 &&
161 Boot->BytesPerSector != 4096)
162 {
163 DPRINT1("BytesPerSector %u\n", Boot->BytesPerSector);
164 *RecognizedFS = FALSE;
165 }
166
167 if (*RecognizedFS &&
168 Boot->FATCount != 1 &&
169 Boot->FATCount != 2)
170 {
171 DPRINT1("FATCount %u\n", Boot->FATCount);
172 *RecognizedFS = FALSE;
173 }
174
175 if (*RecognizedFS &&
176 Boot->Media != 0xf0 &&
177 Boot->Media != 0xf8 &&
178 Boot->Media != 0xf9 &&
179 Boot->Media != 0xfa &&
180 Boot->Media != 0xfb &&
181 Boot->Media != 0xfc &&
182 Boot->Media != 0xfd &&
183 Boot->Media != 0xfe &&
184 Boot->Media != 0xff)
185 {
186 DPRINT1("Media %02x\n", Boot->Media);
187 *RecognizedFS = FALSE;
188 }
189
190 if (*RecognizedFS &&
191 Boot->SectorsPerCluster != 1 &&
192 Boot->SectorsPerCluster != 2 &&
193 Boot->SectorsPerCluster != 4 &&
194 Boot->SectorsPerCluster != 8 &&
195 Boot->SectorsPerCluster != 16 &&
196 Boot->SectorsPerCluster != 32 &&
197 Boot->SectorsPerCluster != 64 &&
198 Boot->SectorsPerCluster != 128)
199 {
200 DPRINT1("SectorsPerCluster %02x\n", Boot->SectorsPerCluster);
201 *RecognizedFS = FALSE;
202 }
203
204 if (*RecognizedFS &&
205 Boot->BytesPerSector * Boot->SectorsPerCluster > 32 * 1024)
206 {
207 DPRINT1("ClusterSize %dx\n", Boot->BytesPerSector * Boot->SectorsPerCluster);
208 *RecognizedFS = FALSE;
209 }
210
211 if (*RecognizedFS)
212 {
213 FatInfo.VolumeID = Boot->VolumeID;
214 FatInfo.FATStart = Boot->ReservedSectors;
215 FatInfo.FATCount = Boot->FATCount;
216 FatInfo.FATSectors = Boot->FATSectors ? Boot->FATSectors : ((struct _BootSector32*) Boot)->FATSectors32;
217 FatInfo.BytesPerSector = Boot->BytesPerSector;
218 FatInfo.SectorsPerCluster = Boot->SectorsPerCluster;
219 FatInfo.BytesPerCluster = FatInfo.BytesPerSector * FatInfo.SectorsPerCluster;
220 FatInfo.rootDirectorySectors = ((Boot->RootEntries * 32) + Boot->BytesPerSector - 1) / Boot->BytesPerSector;
221 FatInfo.rootStart = FatInfo.FATStart + FatInfo.FATCount * FatInfo.FATSectors;
222 FatInfo.dataStart = FatInfo.rootStart + FatInfo.rootDirectorySectors;
223 FatInfo.Sectors = Sectors = Boot->Sectors ? Boot->Sectors : Boot->SectorsHuge;
224 Sectors -= Boot->ReservedSectors + FatInfo.FATCount * FatInfo.FATSectors + FatInfo.rootDirectorySectors;
225 FatInfo.NumberOfClusters = Sectors / Boot->SectorsPerCluster;
226 if (FatInfo.NumberOfClusters < 4085)
227 {
228 DPRINT("FAT12\n");
229 FatInfo.FatType = FAT12;
230 FatInfo.RootCluster = (FatInfo.rootStart - 1) / FatInfo.SectorsPerCluster;
231 }
232 else if (FatInfo.NumberOfClusters >= 65525)
233 {
234 DPRINT("FAT32\n");
235 FatInfo.FatType = FAT32;
236 FatInfo.RootCluster = ((struct _BootSector32*) Boot)->RootCluster;
237 FatInfo.rootStart = FatInfo.dataStart + ((FatInfo.RootCluster - 2) * FatInfo.SectorsPerCluster);
238 FatInfo.VolumeID = ((struct _BootSector32*) Boot)->VolumeID;
239 }
240 else
241 {
242 DPRINT("FAT16\n");
243 FatInfo.FatType = FAT16;
244 FatInfo.RootCluster = FatInfo.rootStart / FatInfo.SectorsPerCluster;
245 }
246
247 if (PartitionInfoIsValid &&
248 FatInfo.Sectors > PartitionInfo.PartitionLength.QuadPart / FatInfo.BytesPerSector)
249 {
250 *RecognizedFS = FALSE;
251 }
252
253 if (pFatInfo && *RecognizedFS)
254 {
255 *pFatInfo = FatInfo;
256 }
257 }
258 }
259
260 ExFreePool(Boot);
261 }
262
263 if (!*RecognizedFS && PartitionInfoIsValid)
264 {
265 BootFatX = ExAllocatePoolWithTag(NonPagedPool, sizeof(struct _BootSectorFatX), TAG_VFAT);
266 if (BootFatX == NULL)
267 {
268 *RecognizedFS=FALSE;
269 return STATUS_INSUFFICIENT_RESOURCES;
270 }
271
272 Offset.QuadPart = 0;
273
274 /* Try to recognize FATX16/FATX32 partitions (Xbox) */
275 Status = VfatReadDisk(DeviceToMount, &Offset, sizeof(struct _BootSectorFatX), (PUCHAR) BootFatX, FALSE);
276 if (NT_SUCCESS(Status))
277 {
278 *RecognizedFS = TRUE;
279 if (BootFatX->SysType[0] != 'F' ||
280 BootFatX->SysType[1] != 'A' ||
281 BootFatX->SysType[2] != 'T' ||
282 BootFatX->SysType[3] != 'X')
283 {
284 DPRINT1("SysType %c%c%c%c\n", BootFatX->SysType[0], BootFatX->SysType[1], BootFatX->SysType[2], BootFatX->SysType[3]);
285 *RecognizedFS=FALSE;
286 }
287
288 if (*RecognizedFS &&
289 BootFatX->SectorsPerCluster != 1 &&
290 BootFatX->SectorsPerCluster != 2 &&
291 BootFatX->SectorsPerCluster != 4 &&
292 BootFatX->SectorsPerCluster != 8 &&
293 BootFatX->SectorsPerCluster != 16 &&
294 BootFatX->SectorsPerCluster != 32 &&
295 BootFatX->SectorsPerCluster != 64 &&
296 BootFatX->SectorsPerCluster != 128)
297 {
298 DPRINT1("SectorsPerCluster %lu\n", BootFatX->SectorsPerCluster);
299 *RecognizedFS=FALSE;
300 }
301
302 if (*RecognizedFS)
303 {
304 FatInfo.BytesPerSector = DiskGeometry.BytesPerSector;
305 FatInfo.SectorsPerCluster = BootFatX->SectorsPerCluster;
306 FatInfo.rootDirectorySectors = BootFatX->SectorsPerCluster;
307 FatInfo.BytesPerCluster = BootFatX->SectorsPerCluster * DiskGeometry.BytesPerSector;
308 FatInfo.Sectors = (ULONG)(PartitionInfo.PartitionLength.QuadPart / DiskGeometry.BytesPerSector);
309 if (FatInfo.Sectors / FatInfo.SectorsPerCluster < 65525)
310 {
311 DPRINT("FATX16\n");
312 FatInfo.FatType = FATX16;
313 }
314 else
315 {
316 DPRINT("FATX32\n");
317 FatInfo.FatType = FATX32;
318 }
319 FatInfo.VolumeID = BootFatX->VolumeID;
320 FatInfo.FATStart = sizeof(struct _BootSectorFatX) / DiskGeometry.BytesPerSector;
321 FatInfo.FATCount = BootFatX->FATCount;
322 FatInfo.FATSectors =
323 ROUND_UP(FatInfo.Sectors / FatInfo.SectorsPerCluster * (FatInfo.FatType == FATX16 ? 2 : 4), 4096) /
324 FatInfo.BytesPerSector;
325 FatInfo.rootStart = FatInfo.FATStart + FatInfo.FATCount * FatInfo.FATSectors;
326 FatInfo.RootCluster = (FatInfo.rootStart - 1) / FatInfo.SectorsPerCluster;
327 FatInfo.dataStart = FatInfo.rootStart + FatInfo.rootDirectorySectors;
328 FatInfo.NumberOfClusters = (FatInfo.Sectors - FatInfo.dataStart) / FatInfo.SectorsPerCluster;
329
330 if (pFatInfo && *RecognizedFS)
331 {
332 *pFatInfo = FatInfo;
333 }
334 }
335 }
336 ExFreePool(BootFatX);
337 }
338
339 DPRINT("VfatHasFileSystem done\n");
340 return Status;
341 }
342
343 /*
344 * FUNCTION: Mounts the device
345 */
346 static
347 NTSTATUS
348 VfatMountDevice(
349 PDEVICE_EXTENSION DeviceExt,
350 PDEVICE_OBJECT DeviceToMount)
351 {
352 NTSTATUS Status;
353 BOOLEAN RecognizedFS;
354
355 DPRINT("Mounting VFAT device...\n");
356
357 Status = VfatHasFileSystem(DeviceToMount, &RecognizedFS, &DeviceExt->FatInfo);
358 if (!NT_SUCCESS(Status))
359 {
360 return Status;
361 }
362 DPRINT("MountVfatdev %u, PAGE_SIZE = %d\n", DeviceExt->FatInfo.BytesPerCluster, PAGE_SIZE);
363
364 return STATUS_SUCCESS;
365 }
366
367
368 /*
369 * FUNCTION: Mount the filesystem
370 */
371 static
372 NTSTATUS
373 VfatMount(
374 PVFAT_IRP_CONTEXT IrpContext)
375 {
376 PDEVICE_OBJECT DeviceObject = NULL;
377 PDEVICE_EXTENSION DeviceExt = NULL;
378 BOOLEAN RecognizedFS;
379 NTSTATUS Status;
380 PVFATFCB Fcb = NULL;
381 PVFATFCB VolumeFcb = NULL;
382 PVFATCCB Ccb = NULL;
383 PDEVICE_OBJECT DeviceToMount;
384 PVPB Vpb;
385 UNICODE_STRING NameU = RTL_CONSTANT_STRING(L"\\$$Fat$$");
386 UNICODE_STRING VolumeNameU = RTL_CONSTANT_STRING(L"\\$$Volume$$");
387 ULONG HashTableSize;
388 ULONG eocMark;
389 FATINFO FatInfo;
390
391 DPRINT("VfatMount(IrpContext %p)\n", IrpContext);
392
393 ASSERT(IrpContext);
394
395 if (IrpContext->DeviceObject != VfatGlobalData->DeviceObject)
396 {
397 Status = STATUS_INVALID_DEVICE_REQUEST;
398 goto ByeBye;
399 }
400
401 DeviceToMount = IrpContext->Stack->Parameters.MountVolume.DeviceObject;
402 Vpb = IrpContext->Stack->Parameters.MountVolume.Vpb;
403
404 Status = VfatHasFileSystem(DeviceToMount, &RecognizedFS, &FatInfo);
405 if (!NT_SUCCESS(Status))
406 {
407 goto ByeBye;
408 }
409
410 if (RecognizedFS == FALSE)
411 {
412 DPRINT("VFAT: Unrecognized Volume\n");
413 Status = STATUS_UNRECOGNIZED_VOLUME;
414 goto ByeBye;
415 }
416
417 /* Use prime numbers for the table size */
418 if (FatInfo.FatType == FAT12)
419 {
420 HashTableSize = 4099; // 4096 = 4 * 1024
421 }
422 else if (FatInfo.FatType == FAT16 ||
423 FatInfo.FatType == FATX16)
424 {
425 HashTableSize = 16411; // 16384 = 16 * 1024
426 }
427 else
428 {
429 HashTableSize = 65537; // 65536 = 64 * 1024;
430 }
431 HashTableSize = FCB_HASH_TABLE_SIZE;
432 DPRINT("VFAT: Recognized volume\n");
433 Status = IoCreateDevice(VfatGlobalData->DriverObject,
434 ROUND_UP(sizeof (DEVICE_EXTENSION), sizeof(ULONG)) + sizeof(HASHENTRY*) * HashTableSize,
435 NULL,
436 FILE_DEVICE_DISK_FILE_SYSTEM,
437 DeviceToMount->Characteristics,
438 FALSE,
439 &DeviceObject);
440 if (!NT_SUCCESS(Status))
441 {
442 goto ByeBye;
443 }
444
445 DeviceExt = DeviceObject->DeviceExtension;
446 RtlZeroMemory(DeviceExt, ROUND_UP(sizeof(DEVICE_EXTENSION), sizeof(ULONG)) + sizeof(HASHENTRY*) * HashTableSize);
447 DeviceExt->FcbHashTable = (HASHENTRY**)((ULONG_PTR)DeviceExt + ROUND_UP(sizeof(DEVICE_EXTENSION), sizeof(ULONG)));
448 DeviceExt->HashTableSize = HashTableSize;
449
450 /* use same vpb as device disk */
451 DeviceObject->Vpb = Vpb;
452 DeviceToMount->Vpb = Vpb;
453
454 Status = VfatMountDevice(DeviceExt, DeviceToMount);
455 if (!NT_SUCCESS(Status))
456 {
457 /* FIXME: delete device object */
458 goto ByeBye;
459 }
460
461 DPRINT("BytesPerSector: %u\n", DeviceExt->FatInfo.BytesPerSector);
462 DPRINT("SectorsPerCluster: %u\n", DeviceExt->FatInfo.SectorsPerCluster);
463 DPRINT("FATCount: %u\n", DeviceExt->FatInfo.FATCount);
464 DPRINT("FATSectors: %u\n", DeviceExt->FatInfo.FATSectors);
465 DPRINT("RootStart: %u\n", DeviceExt->FatInfo.rootStart);
466 DPRINT("DataStart: %u\n", DeviceExt->FatInfo.dataStart);
467 if (DeviceExt->FatInfo.FatType == FAT32)
468 {
469 DPRINT("RootCluster: %u\n", DeviceExt->FatInfo.RootCluster);
470 }
471
472 switch (DeviceExt->FatInfo.FatType)
473 {
474 case FAT12:
475 DeviceExt->GetNextCluster = FAT12GetNextCluster;
476 DeviceExt->FindAndMarkAvailableCluster = FAT12FindAndMarkAvailableCluster;
477 DeviceExt->WriteCluster = FAT12WriteCluster;
478 DeviceExt->CleanShutBitMask = 0;
479 break;
480
481 case FAT16:
482 case FATX16:
483 DeviceExt->GetNextCluster = FAT16GetNextCluster;
484 DeviceExt->FindAndMarkAvailableCluster = FAT16FindAndMarkAvailableCluster;
485 DeviceExt->WriteCluster = FAT16WriteCluster;
486 DeviceExt->CleanShutBitMask = 0x8000;
487 break;
488
489 case FAT32:
490 case FATX32:
491 DeviceExt->GetNextCluster = FAT32GetNextCluster;
492 DeviceExt->FindAndMarkAvailableCluster = FAT32FindAndMarkAvailableCluster;
493 DeviceExt->WriteCluster = FAT32WriteCluster;
494 DeviceExt->CleanShutBitMask = 0x80000000;
495 break;
496 }
497
498 if (DeviceExt->FatInfo.FatType == FATX16 ||
499 DeviceExt->FatInfo.FatType == FATX32)
500 {
501 DeviceExt->Flags |= VCB_IS_FATX;
502 DeviceExt->GetNextDirEntry = FATXGetNextDirEntry;
503 DeviceExt->BaseDateYear = 2000;
504 }
505 else
506 {
507 DeviceExt->GetNextDirEntry = FATGetNextDirEntry;
508 DeviceExt->BaseDateYear = 1980;
509 }
510
511 DeviceExt->StorageDevice = DeviceToMount;
512 DeviceExt->StorageDevice->Vpb->DeviceObject = DeviceObject;
513 DeviceExt->StorageDevice->Vpb->RealDevice = DeviceExt->StorageDevice;
514 DeviceExt->StorageDevice->Vpb->Flags |= VPB_MOUNTED;
515 DeviceObject->StackSize = DeviceExt->StorageDevice->StackSize + 1;
516 DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
517
518 DPRINT("FsDeviceObject %p\n", DeviceObject);
519
520 /* Initialize this resource early ... it's used in VfatCleanup */
521 ExInitializeResourceLite(&DeviceExt->DirResource);
522
523 DeviceExt->FATFileObject = IoCreateStreamFileObject(NULL, DeviceExt->StorageDevice);
524 Fcb = vfatNewFCB(DeviceExt, &NameU);
525 if (Fcb == NULL)
526 {
527 Status = STATUS_INSUFFICIENT_RESOURCES;
528 goto ByeBye;
529 }
530
531 Ccb = ExAllocateFromNPagedLookasideList(&VfatGlobalData->CcbLookasideList);
532 if (Ccb == NULL)
533 {
534 Status = STATUS_INSUFFICIENT_RESOURCES;
535 goto ByeBye;
536 }
537
538 RtlZeroMemory(Ccb, sizeof (VFATCCB));
539 DeviceExt->FATFileObject->FsContext = Fcb;
540 DeviceExt->FATFileObject->FsContext2 = Ccb;
541 DeviceExt->FATFileObject->SectionObjectPointer = &Fcb->SectionObjectPointers;
542 DeviceExt->FATFileObject->PrivateCacheMap = NULL;
543 DeviceExt->FATFileObject->Vpb = DeviceObject->Vpb;
544 Fcb->FileObject = DeviceExt->FATFileObject;
545
546 Fcb->Flags |= FCB_IS_FAT;
547
548 Fcb->RFCB.FileSize.QuadPart = DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector;
549 Fcb->RFCB.ValidDataLength = Fcb->RFCB.FileSize;
550 Fcb->RFCB.AllocationSize = Fcb->RFCB.FileSize;
551
552 _SEH2_TRY
553 {
554 CcInitializeCacheMap(DeviceExt->FATFileObject,
555 (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
556 TRUE,
557 &VfatGlobalData->CacheMgrCallbacks,
558 Fcb);
559 }
560 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
561 {
562 Status = _SEH2_GetExceptionCode();
563 goto ByeBye;
564 }
565 _SEH2_END;
566
567 DeviceExt->LastAvailableCluster = 2;
568 ExInitializeResourceLite(&DeviceExt->FatResource);
569
570 InitializeListHead(&DeviceExt->FcbListHead);
571
572 VolumeFcb = vfatNewFCB(DeviceExt, &VolumeNameU);
573 if (VolumeFcb == NULL)
574 {
575 Status = STATUS_INSUFFICIENT_RESOURCES;
576 goto ByeBye;
577 }
578
579 VolumeFcb->Flags = FCB_IS_VOLUME;
580 VolumeFcb->RFCB.FileSize.QuadPart = DeviceExt->FatInfo.Sectors * DeviceExt->FatInfo.BytesPerSector;
581 VolumeFcb->RFCB.ValidDataLength = VolumeFcb->RFCB.FileSize;
582 VolumeFcb->RFCB.AllocationSize = VolumeFcb->RFCB.FileSize;
583 DeviceExt->VolumeFcb = VolumeFcb;
584
585 ExAcquireResourceExclusiveLite(&VfatGlobalData->VolumeListLock, TRUE);
586 InsertHeadList(&VfatGlobalData->VolumeListHead, &DeviceExt->VolumeListEntry);
587 ExReleaseResourceLite(&VfatGlobalData->VolumeListLock);
588
589 /* read serial number */
590 DeviceObject->Vpb->SerialNumber = DeviceExt->FatInfo.VolumeID;
591
592 /* read volume label */
593 ReadVolumeLabel(DeviceExt, DeviceObject->Vpb);
594
595 /* read clean shutdown bit status */
596 Status = GetNextCluster(DeviceExt, 1, &eocMark);
597 if (NT_SUCCESS(Status))
598 {
599 if (eocMark & DeviceExt->CleanShutBitMask)
600 {
601 /* unset clean shutdown bit */
602 eocMark &= ~DeviceExt->CleanShutBitMask;
603 WriteCluster(DeviceExt, 1, eocMark);
604 VolumeFcb->Flags |= VCB_CLEAR_DIRTY;
605 }
606 }
607
608 VolumeFcb->Flags |= VCB_IS_DIRTY;
609
610 FsRtlNotifyVolumeEvent(DeviceExt->FATFileObject, FSRTL_VOLUME_MOUNT);
611 FsRtlNotifyInitializeSync(&DeviceExt->NotifySync);
612 InitializeListHead(&DeviceExt->NotifyList);
613
614 Status = STATUS_SUCCESS;
615
616 ByeBye:
617 if (!NT_SUCCESS(Status))
618 {
619 /* Cleanup */
620 if (DeviceExt && DeviceExt->FATFileObject)
621 ObDereferenceObject (DeviceExt->FATFileObject);
622 if (Fcb)
623 vfatDestroyFCB(Fcb);
624 if (Ccb)
625 vfatDestroyCCB(Ccb);
626 if (DeviceObject)
627 IoDeleteDevice(DeviceObject);
628 }
629
630 return Status;
631 }
632
633
634 /*
635 * FUNCTION: Verify the filesystem
636 */
637 static
638 NTSTATUS
639 VfatVerify(
640 PVFAT_IRP_CONTEXT IrpContext)
641 {
642 PDEVICE_OBJECT DeviceToVerify;
643 NTSTATUS Status = STATUS_SUCCESS;
644 FATINFO FatInfo;
645 BOOLEAN RecognizedFS;
646 PDEVICE_EXTENSION DeviceExt = IrpContext->DeviceExt;
647
648 DPRINT("VfatVerify(IrpContext %p)\n", IrpContext);
649
650 DeviceToVerify = IrpContext->Stack->Parameters.VerifyVolume.DeviceObject;
651 Status = VfatBlockDeviceIoControl(DeviceToVerify,
652 IOCTL_DISK_CHECK_VERIFY,
653 NULL,
654 0,
655 NULL,
656 0,
657 TRUE);
658 DeviceToVerify->Flags &= ~DO_VERIFY_VOLUME;
659 if (!NT_SUCCESS(Status) && Status != STATUS_VERIFY_REQUIRED)
660 {
661 DPRINT("VfatBlockDeviceIoControl() failed (Status %lx)\n", Status);
662 Status = STATUS_WRONG_VOLUME;
663 }
664 else
665 {
666 Status = VfatHasFileSystem(DeviceToVerify, &RecognizedFS, &FatInfo);
667 if (!NT_SUCCESS(Status) || RecognizedFS == FALSE)
668 {
669 Status = STATUS_WRONG_VOLUME;
670 }
671 else if (sizeof(FATINFO) == RtlCompareMemory(&FatInfo, &DeviceExt->FatInfo, sizeof(FATINFO)))
672 {
673 /*
674 * FIXME:
675 * Preformated floppy disks have very often a serial number of 0000:0000.
676 * We should calculate a crc sum over the sectors from the root directory as secondary volume number.
677 * Each write to the root directory must update this crc sum.
678 */
679 }
680 else
681 {
682 Status = STATUS_WRONG_VOLUME;
683 }
684 }
685
686 return Status;
687 }
688
689
690 static
691 NTSTATUS
692 VfatGetVolumeBitmap(
693 PVFAT_IRP_CONTEXT IrpContext)
694 {
695 DPRINT("VfatGetVolumeBitmap (IrpContext %p)\n", IrpContext);
696 return STATUS_INVALID_DEVICE_REQUEST;
697 }
698
699
700 static
701 NTSTATUS
702 VfatGetRetrievalPointers(
703 PVFAT_IRP_CONTEXT IrpContext)
704 {
705 PIO_STACK_LOCATION Stack;
706 LARGE_INTEGER Vcn;
707 PRETRIEVAL_POINTERS_BUFFER RetrievalPointers;
708 PFILE_OBJECT FileObject;
709 ULONG MaxExtentCount;
710 PVFATFCB Fcb;
711 PDEVICE_EXTENSION DeviceExt;
712 ULONG FirstCluster;
713 ULONG CurrentCluster;
714 ULONG LastCluster;
715 NTSTATUS Status;
716
717 DPRINT("VfatGetRetrievalPointers(IrpContext %p)\n", IrpContext);
718
719 DeviceExt = IrpContext->DeviceExt;
720 FileObject = IrpContext->FileObject;
721 Stack = IrpContext->Stack;
722 if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STARTING_VCN_INPUT_BUFFER) ||
723 Stack->Parameters.DeviceIoControl.Type3InputBuffer == NULL)
724 {
725 return STATUS_INVALID_PARAMETER;
726 }
727
728 if (IrpContext->Irp->UserBuffer == NULL ||
729 Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(RETRIEVAL_POINTERS_BUFFER))
730 {
731 return STATUS_BUFFER_TOO_SMALL;
732 }
733
734 Fcb = FileObject->FsContext;
735
736 ExAcquireResourceSharedLite(&Fcb->MainResource, TRUE);
737
738 Vcn = ((PSTARTING_VCN_INPUT_BUFFER)Stack->Parameters.DeviceIoControl.Type3InputBuffer)->StartingVcn;
739 RetrievalPointers = IrpContext->Irp->UserBuffer;
740
741 MaxExtentCount = ((Stack->Parameters.DeviceIoControl.OutputBufferLength - sizeof(RetrievalPointers->ExtentCount) - sizeof(RetrievalPointers->StartingVcn)) / sizeof(RetrievalPointers->Extents[0]));
742
743 if (Vcn.QuadPart >= Fcb->RFCB.AllocationSize.QuadPart / DeviceExt->FatInfo.BytesPerCluster)
744 {
745 Status = STATUS_INVALID_PARAMETER;
746 goto ByeBye;
747 }
748
749 CurrentCluster = FirstCluster = vfatDirEntryGetFirstCluster(DeviceExt, &Fcb->entry);
750 Status = OffsetToCluster(DeviceExt, FirstCluster,
751 Vcn.u.LowPart * DeviceExt->FatInfo.BytesPerCluster,
752 &CurrentCluster, FALSE);
753 if (!NT_SUCCESS(Status))
754 {
755 goto ByeBye;
756 }
757
758 RetrievalPointers->StartingVcn = Vcn;
759 RetrievalPointers->ExtentCount = 0;
760 RetrievalPointers->Extents[0].Lcn.u.HighPart = 0;
761 RetrievalPointers->Extents[0].Lcn.u.LowPart = CurrentCluster - 2;
762 LastCluster = 0;
763 while (CurrentCluster != 0xffffffff && RetrievalPointers->ExtentCount < MaxExtentCount)
764 {
765 LastCluster = CurrentCluster;
766 Status = NextCluster(DeviceExt, CurrentCluster, &CurrentCluster, FALSE);
767 Vcn.QuadPart++;
768 if (!NT_SUCCESS(Status))
769 {
770 goto ByeBye;
771 }
772
773 if (LastCluster + 1 != CurrentCluster)
774 {
775 RetrievalPointers->Extents[RetrievalPointers->ExtentCount].NextVcn = Vcn;
776 RetrievalPointers->ExtentCount++;
777 if (RetrievalPointers->ExtentCount < MaxExtentCount)
778 {
779 RetrievalPointers->Extents[RetrievalPointers->ExtentCount].Lcn.u.HighPart = 0;
780 RetrievalPointers->Extents[RetrievalPointers->ExtentCount].Lcn.u.LowPart = CurrentCluster - 2;
781 }
782 }
783 }
784
785 IrpContext->Irp->IoStatus.Information = sizeof(RETRIEVAL_POINTERS_BUFFER) + (sizeof(RetrievalPointers->Extents[0]) * (RetrievalPointers->ExtentCount - 1));
786 Status = STATUS_SUCCESS;
787
788 ByeBye:
789 ExReleaseResourceLite(&Fcb->MainResource);
790
791 return Status;
792 }
793
794 static
795 NTSTATUS
796 VfatMoveFile(
797 PVFAT_IRP_CONTEXT IrpContext)
798 {
799 DPRINT("VfatMoveFile(IrpContext %p)\n", IrpContext);
800 return STATUS_INVALID_DEVICE_REQUEST;
801 }
802
803 static
804 NTSTATUS
805 VfatIsVolumeDirty(
806 PVFAT_IRP_CONTEXT IrpContext)
807 {
808 PULONG Flags;
809
810 DPRINT("VfatIsVolumeDirty(IrpContext %p)\n", IrpContext);
811
812 if (IrpContext->Stack->Parameters.FileSystemControl.OutputBufferLength != sizeof(ULONG))
813 return STATUS_INVALID_BUFFER_SIZE;
814 else if (!IrpContext->Irp->AssociatedIrp.SystemBuffer)
815 return STATUS_INVALID_USER_BUFFER;
816
817 Flags = (PULONG)IrpContext->Irp->AssociatedIrp.SystemBuffer;
818 *Flags = 0;
819
820 if ((IrpContext->DeviceExt->VolumeFcb->Flags & VCB_IS_DIRTY) &&
821 !(IrpContext->DeviceExt->VolumeFcb->Flags & VCB_CLEAR_DIRTY))
822 {
823 *Flags |= VOLUME_IS_DIRTY;
824 }
825
826 return STATUS_SUCCESS;
827 }
828
829 static
830 NTSTATUS
831 VfatMarkVolumeDirty(
832 PVFAT_IRP_CONTEXT IrpContext)
833 {
834 ULONG eocMark;
835 PDEVICE_EXTENSION DeviceExt;
836 NTSTATUS Status = STATUS_SUCCESS;
837
838 DPRINT("VfatMarkVolumeDirty(IrpContext %p)\n", IrpContext);
839 DeviceExt = IrpContext->DeviceExt;
840
841 if (!(DeviceExt->VolumeFcb->Flags & VCB_IS_DIRTY))
842 {
843 Status = GetNextCluster(DeviceExt, 1, &eocMark);
844 if (NT_SUCCESS(Status))
845 {
846 /* unset clean shutdown bit */
847 eocMark &= ~DeviceExt->CleanShutBitMask;
848 Status = WriteCluster(DeviceExt, 1, eocMark);
849 }
850 }
851
852 DeviceExt->VolumeFcb->Flags &= ~VCB_CLEAR_DIRTY;
853
854 return Status;
855 }
856
857 /*
858 * FUNCTION: File system control
859 */
860 NTSTATUS
861 VfatFileSystemControl(
862 PVFAT_IRP_CONTEXT IrpContext)
863 {
864 NTSTATUS Status;
865
866 DPRINT("VfatFileSystemControl(IrpContext %p)\n", IrpContext);
867
868 ASSERT(IrpContext);
869 ASSERT(IrpContext->Irp);
870 ASSERT(IrpContext->Stack);
871
872 IrpContext->Irp->IoStatus.Information = 0;
873
874 switch (IrpContext->MinorFunction)
875 {
876 case IRP_MN_KERNEL_CALL:
877 case IRP_MN_USER_FS_REQUEST:
878 switch(IrpContext->Stack->Parameters.DeviceIoControl.IoControlCode)
879 {
880 case FSCTL_GET_VOLUME_BITMAP:
881 Status = VfatGetVolumeBitmap(IrpContext);
882 break;
883
884 case FSCTL_GET_RETRIEVAL_POINTERS:
885 Status = VfatGetRetrievalPointers(IrpContext);
886 break;
887
888 case FSCTL_MOVE_FILE:
889 Status = VfatMoveFile(IrpContext);
890 break;
891
892 case FSCTL_IS_VOLUME_DIRTY:
893 Status = VfatIsVolumeDirty(IrpContext);
894 break;
895
896 case FSCTL_MARK_VOLUME_DIRTY:
897 Status = VfatMarkVolumeDirty(IrpContext);
898 break;
899
900 default:
901 Status = STATUS_INVALID_DEVICE_REQUEST;
902 }
903 break;
904
905 case IRP_MN_MOUNT_VOLUME:
906 Status = VfatMount(IrpContext);
907 break;
908
909 case IRP_MN_VERIFY_VOLUME:
910 DPRINT("VFATFS: IRP_MN_VERIFY_VOLUME\n");
911 Status = VfatVerify(IrpContext);
912 break;
913
914 default:
915 DPRINT("VFAT FSC: MinorFunction %u\n", IrpContext->MinorFunction);
916 Status = STATUS_INVALID_DEVICE_REQUEST;
917 break;
918 }
919
920 IrpContext->Irp->IoStatus.Status = Status;
921
922 IoCompleteRequest(IrpContext->Irp, IO_NO_INCREMENT);
923 VfatFreeIrpContext(IrpContext);
924 return Status;
925 }