[FASTFAT] Fix size checking in VfatGetFileNameInformation()
[reactos.git] / drivers / filesystems / fastfat / rw.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: drivers/fs/vfat/rw.c
5 * PURPOSE: VFAT Filesystem
6 * PROGRAMMER: Jason Filby (jasonfilby@yahoo.com)
7 *
8 */
9
10 /* INCLUDES *****************************************************************/
11
12 #include "vfat.h"
13
14 #define NDEBUG
15 #include <debug.h>
16
17 /*
18 * Uncomment to enable strict verification of cluster/offset pair
19 * caching. If this option is enabled you lose all the benefits of
20 * the caching and the read/write operations will actually be
21 * slower. It's meant only for debugging!!!
22 * - Filip Navara, 26/07/2004
23 */
24 /* #define DEBUG_VERIFY_OFFSET_CACHING */
25
26 /* FUNCTIONS *****************************************************************/
27
28 /*
29 * Return the next cluster in a FAT chain, possibly extending the chain if
30 * necessary
31 */
32 NTSTATUS
33 NextCluster(
34 PDEVICE_EXTENSION DeviceExt,
35 ULONG FirstCluster,
36 PULONG CurrentCluster,
37 BOOLEAN Extend)
38 {
39 if (FirstCluster == 1)
40 {
41 (*CurrentCluster) += DeviceExt->FatInfo.SectorsPerCluster;
42 return STATUS_SUCCESS;
43 }
44 else
45 {
46 if (Extend)
47 return GetNextClusterExtend(DeviceExt, (*CurrentCluster), CurrentCluster);
48 else
49 return GetNextCluster(DeviceExt, (*CurrentCluster), CurrentCluster);
50 }
51 }
52
53 NTSTATUS
54 OffsetToCluster(
55 PDEVICE_EXTENSION DeviceExt,
56 ULONG FirstCluster,
57 ULONG FileOffset,
58 PULONG Cluster,
59 BOOLEAN Extend)
60 {
61 ULONG CurrentCluster;
62 ULONG i;
63 NTSTATUS Status;
64 /*
65 DPRINT("OffsetToCluster(DeviceExt %x, Fcb %x, FirstCluster %x,"
66 " FileOffset %x, Cluster %x, Extend %d)\n", DeviceExt,
67 Fcb, FirstCluster, FileOffset, Cluster, Extend);
68 */
69 if (FirstCluster == 0)
70 {
71 DbgPrint("OffsetToCluster is called with FirstCluster = 0!\n");
72 ASSERT(FALSE);
73 }
74
75 if (FirstCluster == 1)
76 {
77 /* root of FAT16 or FAT12 */
78 *Cluster = DeviceExt->FatInfo.rootStart + FileOffset
79 / (DeviceExt->FatInfo.BytesPerCluster) * DeviceExt->FatInfo.SectorsPerCluster;
80 return STATUS_SUCCESS;
81 }
82 else
83 {
84 CurrentCluster = FirstCluster;
85 if (Extend)
86 {
87 for (i = 0; i < FileOffset / DeviceExt->FatInfo.BytesPerCluster; i++)
88 {
89 Status = GetNextClusterExtend (DeviceExt, CurrentCluster, &CurrentCluster);
90 if (!NT_SUCCESS(Status))
91 return Status;
92 }
93 *Cluster = CurrentCluster;
94 }
95 else
96 {
97 for (i = 0; i < FileOffset / DeviceExt->FatInfo.BytesPerCluster; i++)
98 {
99 Status = GetNextCluster (DeviceExt, CurrentCluster, &CurrentCluster);
100 if (!NT_SUCCESS(Status))
101 return Status;
102 }
103 *Cluster = CurrentCluster;
104 }
105 return STATUS_SUCCESS;
106 }
107 }
108
109 /*
110 * FUNCTION: Reads data from a file
111 */
112 static
113 NTSTATUS
114 VfatReadFileData(
115 PVFAT_IRP_CONTEXT IrpContext,
116 ULONG Length,
117 LARGE_INTEGER ReadOffset,
118 PULONG LengthRead)
119 {
120 ULONG CurrentCluster;
121 ULONG FirstCluster;
122 ULONG StartCluster;
123 ULONG ClusterCount;
124 LARGE_INTEGER StartOffset;
125 PDEVICE_EXTENSION DeviceExt;
126 BOOLEAN First = TRUE;
127 PVFATFCB Fcb;
128 NTSTATUS Status;
129 ULONG BytesDone;
130 ULONG BytesPerSector;
131 ULONG BytesPerCluster;
132 ULONG LastCluster;
133 ULONG LastOffset;
134
135 /* PRECONDITION */
136 ASSERT(IrpContext);
137 DeviceExt = IrpContext->DeviceExt;
138 ASSERT(DeviceExt);
139 ASSERT(DeviceExt->FatInfo.BytesPerCluster);
140 ASSERT(IrpContext->FileObject);
141 ASSERT(IrpContext->FileObject->FsContext2 != NULL);
142
143 DPRINT("VfatReadFileData(DeviceExt %p, FileObject %p, "
144 "Length %u, ReadOffset 0x%I64x)\n", DeviceExt,
145 IrpContext->FileObject, Length, ReadOffset.QuadPart);
146
147 *LengthRead = 0;
148
149 Fcb = IrpContext->FileObject->FsContext;
150 BytesPerSector = DeviceExt->FatInfo.BytesPerSector;
151 BytesPerCluster = DeviceExt->FatInfo.BytesPerCluster;
152
153 ASSERT(ReadOffset.QuadPart + Length <= ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector));
154 ASSERT(ReadOffset.u.LowPart % BytesPerSector == 0);
155 ASSERT(Length % BytesPerSector == 0);
156
157 /* Is this a read of the FAT? */
158 if (BooleanFlagOn(Fcb->Flags, FCB_IS_FAT))
159 {
160 ReadOffset.QuadPart += DeviceExt->FatInfo.FATStart * BytesPerSector;
161 Status = VfatReadDiskPartial(IrpContext, &ReadOffset, Length, 0, TRUE);
162
163 if (NT_SUCCESS(Status))
164 {
165 *LengthRead = Length;
166 }
167 else
168 {
169 DPRINT1("FAT reading failed, Status %x\n", Status);
170 }
171 return Status;
172 }
173
174 /* Is this a read of the Volume ? */
175 if (BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME))
176 {
177 Status = VfatReadDiskPartial(IrpContext, &ReadOffset, Length, 0, TRUE);
178 if (NT_SUCCESS(Status))
179 {
180 *LengthRead = Length;
181 }
182 else
183 {
184 DPRINT1("Volume reading failed, Status %x\n", Status);
185 }
186 return Status;
187 }
188
189 /* Find the first cluster */
190 FirstCluster =
191 CurrentCluster = vfatDirEntryGetFirstCluster (DeviceExt, &Fcb->entry);
192
193 if (FirstCluster == 1)
194 {
195 /* Directory of FAT12/16 needs a special handling */
196 if (ReadOffset.u.LowPart + Length > DeviceExt->FatInfo.rootDirectorySectors * BytesPerSector)
197 {
198 Length = DeviceExt->FatInfo.rootDirectorySectors * BytesPerSector - ReadOffset.u.LowPart;
199 }
200 ReadOffset.u.LowPart += DeviceExt->FatInfo.rootStart * BytesPerSector;
201
202 /* Fire up the read command */
203 Status = VfatReadDiskPartial (IrpContext, &ReadOffset, Length, 0, TRUE);
204 if (NT_SUCCESS(Status))
205 {
206 *LengthRead = Length;
207 }
208 return Status;
209 }
210
211 ExAcquireFastMutex(&Fcb->LastMutex);
212 LastCluster = Fcb->LastCluster;
213 LastOffset = Fcb->LastOffset;
214 ExReleaseFastMutex(&Fcb->LastMutex);
215
216 /* Find the cluster to start the read from */
217 if (LastCluster > 0 && ReadOffset.u.LowPart >= LastOffset)
218 {
219 Status = OffsetToCluster(DeviceExt, LastCluster,
220 ROUND_DOWN(ReadOffset.u.LowPart, BytesPerCluster) -
221 LastOffset,
222 &CurrentCluster, FALSE);
223 #ifdef DEBUG_VERIFY_OFFSET_CACHING
224 /* DEBUG VERIFICATION */
225 {
226 ULONG CorrectCluster;
227 OffsetToCluster(DeviceExt, FirstCluster,
228 ROUND_DOWN(ReadOffset.u.LowPart, BytesPerCluster),
229 &CorrectCluster, FALSE);
230 if (CorrectCluster != CurrentCluster)
231 KeBugCheck(FAT_FILE_SYSTEM);
232 }
233 #endif
234 }
235 else
236 {
237 Status = OffsetToCluster(DeviceExt, FirstCluster,
238 ROUND_DOWN(ReadOffset.u.LowPart, BytesPerCluster),
239 &CurrentCluster, FALSE);
240 }
241
242 if (!NT_SUCCESS(Status))
243 {
244 return Status;
245 }
246
247 ExAcquireFastMutex(&Fcb->LastMutex);
248 Fcb->LastCluster = CurrentCluster;
249 Fcb->LastOffset = ROUND_DOWN (ReadOffset.u.LowPart, BytesPerCluster);
250 ExReleaseFastMutex(&Fcb->LastMutex);
251
252 KeInitializeEvent(&IrpContext->Event, NotificationEvent, FALSE);
253 IrpContext->RefCount = 1;
254
255 while (Length > 0 && CurrentCluster != 0xffffffff)
256 {
257 StartCluster = CurrentCluster;
258 StartOffset.QuadPart = ClusterToSector(DeviceExt, StartCluster) * BytesPerSector;
259 BytesDone = 0;
260 ClusterCount = 0;
261
262 do
263 {
264 ClusterCount++;
265 if (First)
266 {
267 BytesDone = min (Length, BytesPerCluster - (ReadOffset.u.LowPart % BytesPerCluster));
268 StartOffset.QuadPart += ReadOffset.u.LowPart % BytesPerCluster;
269 First = FALSE;
270 }
271 else
272 {
273 if (Length - BytesDone > BytesPerCluster)
274 {
275 BytesDone += BytesPerCluster;
276 }
277 else
278 {
279 BytesDone = Length;
280 }
281 }
282 Status = NextCluster(DeviceExt, FirstCluster, &CurrentCluster, FALSE);
283 }
284 while (StartCluster + ClusterCount == CurrentCluster && NT_SUCCESS(Status) && Length > BytesDone);
285 DPRINT("start %08x, next %08x, count %u\n",
286 StartCluster, CurrentCluster, ClusterCount);
287
288 ExAcquireFastMutex(&Fcb->LastMutex);
289 Fcb->LastCluster = StartCluster + (ClusterCount - 1);
290 Fcb->LastOffset = ROUND_DOWN(ReadOffset.u.LowPart, BytesPerCluster) + (ClusterCount - 1) * BytesPerCluster;
291 ExReleaseFastMutex(&Fcb->LastMutex);
292
293 /* Fire up the read command */
294 Status = VfatReadDiskPartial (IrpContext, &StartOffset, BytesDone, *LengthRead, FALSE);
295 if (!NT_SUCCESS(Status) && Status != STATUS_PENDING)
296 {
297 break;
298 }
299 *LengthRead += BytesDone;
300 Length -= BytesDone;
301 ReadOffset.u.LowPart += BytesDone;
302 }
303
304 if (InterlockedDecrement((PLONG)&IrpContext->RefCount) != 0)
305 {
306 KeWaitForSingleObject(&IrpContext->Event, Executive, KernelMode, FALSE, NULL);
307 }
308
309 if (NT_SUCCESS(Status) || Status == STATUS_PENDING)
310 {
311 if (Length > 0)
312 {
313 Status = STATUS_UNSUCCESSFUL;
314 }
315 else
316 {
317 Status = IrpContext->Irp->IoStatus.Status;
318 }
319 }
320
321 return Status;
322 }
323
324 static
325 NTSTATUS
326 VfatWriteFileData(
327 PVFAT_IRP_CONTEXT IrpContext,
328 ULONG Length,
329 LARGE_INTEGER WriteOffset)
330 {
331 PDEVICE_EXTENSION DeviceExt;
332 PVFATFCB Fcb;
333 ULONG Count;
334 ULONG FirstCluster;
335 ULONG CurrentCluster;
336 ULONG BytesDone;
337 ULONG StartCluster;
338 ULONG ClusterCount;
339 NTSTATUS Status = STATUS_SUCCESS;
340 BOOLEAN First = TRUE;
341 ULONG BytesPerSector;
342 ULONG BytesPerCluster;
343 LARGE_INTEGER StartOffset;
344 ULONG BufferOffset;
345 ULONG LastCluster;
346 ULONG LastOffset;
347
348 /* PRECONDITION */
349 ASSERT(IrpContext);
350 DeviceExt = IrpContext->DeviceExt;
351 ASSERT(DeviceExt);
352 ASSERT(DeviceExt->FatInfo.BytesPerCluster);
353 ASSERT(IrpContext->FileObject);
354 ASSERT(IrpContext->FileObject->FsContext2 != NULL);
355
356 Fcb = IrpContext->FileObject->FsContext;
357 BytesPerCluster = DeviceExt->FatInfo.BytesPerCluster;
358 BytesPerSector = DeviceExt->FatInfo.BytesPerSector;
359
360 DPRINT("VfatWriteFileData(DeviceExt %p, FileObject %p, "
361 "Length %u, WriteOffset 0x%I64x), '%wZ'\n", DeviceExt,
362 IrpContext->FileObject, Length, WriteOffset.QuadPart,
363 &Fcb->PathNameU);
364
365 ASSERT(WriteOffset.QuadPart + Length <= Fcb->RFCB.AllocationSize.QuadPart);
366 ASSERT(WriteOffset.u.LowPart % BytesPerSector == 0);
367 ASSERT(Length % BytesPerSector == 0);
368
369 /* Is this a write of the volume? */
370 if (BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME))
371 {
372 Status = VfatWriteDiskPartial(IrpContext, &WriteOffset, Length, 0, TRUE);
373 if (!NT_SUCCESS(Status))
374 {
375 DPRINT1("Volume writing failed, Status %x\n", Status);
376 }
377 return Status;
378 }
379
380 /* Is this a write to the FAT? */
381 if (BooleanFlagOn(Fcb->Flags, FCB_IS_FAT))
382 {
383 WriteOffset.u.LowPart += DeviceExt->FatInfo.FATStart * BytesPerSector;
384 IrpContext->RefCount = 1;
385 for (Count = 0; Count < DeviceExt->FatInfo.FATCount; Count++)
386 {
387 Status = VfatWriteDiskPartial(IrpContext, &WriteOffset, Length, 0, FALSE);
388 if (!NT_SUCCESS(Status) && Status != STATUS_PENDING)
389 {
390 DPRINT1("FAT writing failed, Status %x\n", Status);
391 break;
392 }
393 WriteOffset.u.LowPart += Fcb->RFCB.FileSize.u.LowPart;
394 }
395
396 if (InterlockedDecrement((PLONG)&IrpContext->RefCount) != 0)
397 {
398 KeWaitForSingleObject(&IrpContext->Event, Executive, KernelMode, FALSE, NULL);
399 }
400
401 if (NT_SUCCESS(Status) || Status == STATUS_PENDING)
402 {
403 Status = IrpContext->Irp->IoStatus.Status;
404 }
405 return Status;
406 }
407
408 /*
409 * Find the first cluster
410 */
411 FirstCluster =
412 CurrentCluster = vfatDirEntryGetFirstCluster (DeviceExt, &Fcb->entry);
413
414 if (FirstCluster == 1)
415 {
416 ASSERT(WriteOffset.u.LowPart + Length <= DeviceExt->FatInfo.rootDirectorySectors * BytesPerSector);
417 // Directory of FAT12/16 needs a special handling
418 WriteOffset.u.LowPart += DeviceExt->FatInfo.rootStart * BytesPerSector;
419 // Fire up the write command
420 Status = VfatWriteDiskPartial (IrpContext, &WriteOffset, Length, 0, TRUE);
421 return Status;
422 }
423
424 ExAcquireFastMutex(&Fcb->LastMutex);
425 LastCluster = Fcb->LastCluster;
426 LastOffset = Fcb->LastOffset;
427 ExReleaseFastMutex(&Fcb->LastMutex);
428
429 /*
430 * Find the cluster to start the write from
431 */
432 if (LastCluster > 0 && WriteOffset.u.LowPart >= LastOffset)
433 {
434 Status = OffsetToCluster(DeviceExt, LastCluster,
435 ROUND_DOWN(WriteOffset.u.LowPart, BytesPerCluster) -
436 LastOffset,
437 &CurrentCluster, FALSE);
438 #ifdef DEBUG_VERIFY_OFFSET_CACHING
439 /* DEBUG VERIFICATION */
440 {
441 ULONG CorrectCluster;
442 OffsetToCluster(DeviceExt, FirstCluster,
443 ROUND_DOWN(WriteOffset.u.LowPart, BytesPerCluster),
444 &CorrectCluster, FALSE);
445 if (CorrectCluster != CurrentCluster)
446 KeBugCheck(FAT_FILE_SYSTEM);
447 }
448 #endif
449 }
450 else
451 {
452 Status = OffsetToCluster(DeviceExt, FirstCluster,
453 ROUND_DOWN(WriteOffset.u.LowPart, BytesPerCluster),
454 &CurrentCluster, FALSE);
455 }
456
457 if (!NT_SUCCESS(Status))
458 {
459 return Status;
460 }
461
462 ExAcquireFastMutex(&Fcb->LastMutex);
463 Fcb->LastCluster = CurrentCluster;
464 Fcb->LastOffset = ROUND_DOWN (WriteOffset.u.LowPart, BytesPerCluster);
465 ExReleaseFastMutex(&Fcb->LastMutex);
466
467 IrpContext->RefCount = 1;
468 BufferOffset = 0;
469
470 while (Length > 0 && CurrentCluster != 0xffffffff)
471 {
472 StartCluster = CurrentCluster;
473 StartOffset.QuadPart = ClusterToSector(DeviceExt, StartCluster) * BytesPerSector;
474 BytesDone = 0;
475 ClusterCount = 0;
476
477 do
478 {
479 ClusterCount++;
480 if (First)
481 {
482 BytesDone = min (Length, BytesPerCluster - (WriteOffset.u.LowPart % BytesPerCluster));
483 StartOffset.QuadPart += WriteOffset.u.LowPart % BytesPerCluster;
484 First = FALSE;
485 }
486 else
487 {
488 if (Length - BytesDone > BytesPerCluster)
489 {
490 BytesDone += BytesPerCluster;
491 }
492 else
493 {
494 BytesDone = Length;
495 }
496 }
497 Status = NextCluster(DeviceExt, FirstCluster, &CurrentCluster, FALSE);
498 }
499 while (StartCluster + ClusterCount == CurrentCluster && NT_SUCCESS(Status) && Length > BytesDone);
500 DPRINT("start %08x, next %08x, count %u\n",
501 StartCluster, CurrentCluster, ClusterCount);
502
503 ExAcquireFastMutex(&Fcb->LastMutex);
504 Fcb->LastCluster = StartCluster + (ClusterCount - 1);
505 Fcb->LastOffset = ROUND_DOWN(WriteOffset.u.LowPart, BytesPerCluster) + (ClusterCount - 1) * BytesPerCluster;
506 ExReleaseFastMutex(&Fcb->LastMutex);
507
508 // Fire up the write command
509 Status = VfatWriteDiskPartial (IrpContext, &StartOffset, BytesDone, BufferOffset, FALSE);
510 if (!NT_SUCCESS(Status) && Status != STATUS_PENDING)
511 {
512 break;
513 }
514 BufferOffset += BytesDone;
515 Length -= BytesDone;
516 WriteOffset.u.LowPart += BytesDone;
517 }
518
519 if (InterlockedDecrement((PLONG)&IrpContext->RefCount) != 0)
520 {
521 KeWaitForSingleObject(&IrpContext->Event, Executive, KernelMode, FALSE, NULL);
522 }
523
524 if (NT_SUCCESS(Status) || Status == STATUS_PENDING)
525 {
526 if (Length > 0)
527 {
528 Status = STATUS_UNSUCCESSFUL;
529 }
530 else
531 {
532 Status = IrpContext->Irp->IoStatus.Status;
533 }
534 }
535 return Status;
536 }
537
538 NTSTATUS
539 VfatRead(
540 PVFAT_IRP_CONTEXT IrpContext)
541 {
542 NTSTATUS Status;
543 PVFATFCB Fcb;
544 ULONG Length = 0;
545 ULONG ReturnedLength = 0;
546 PERESOURCE Resource = NULL;
547 LARGE_INTEGER ByteOffset;
548 PVOID Buffer;
549 ULONG BytesPerSector;
550 BOOLEAN PagingIo, CanWait, IsVolume, NoCache;
551
552 ASSERT(IrpContext);
553
554 DPRINT("VfatRead(IrpContext %p)\n", IrpContext);
555
556 ASSERT(IrpContext->DeviceObject);
557
558 PagingIo = BooleanFlagOn(IrpContext->Irp->Flags, IRP_PAGING_IO);
559 CanWait = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT);
560 NoCache = BooleanFlagOn(IrpContext->Irp->Flags, IRP_NOCACHE);
561
562 // This request is not allowed on the main device object
563 if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
564 {
565 DPRINT("VfatRead is called with the main device object.\n");
566 Status = STATUS_INVALID_DEVICE_REQUEST;
567 goto ByeBye;
568 }
569
570 ASSERT(IrpContext->DeviceExt);
571 ASSERT(IrpContext->FileObject);
572 Fcb = IrpContext->FileObject->FsContext;
573 ASSERT(Fcb);
574
575 IsVolume = BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME);
576
577 if (BooleanFlagOn(Fcb->Flags, FCB_IS_PAGE_FILE))
578 {
579 PFATINFO FatInfo = &IrpContext->DeviceExt->FatInfo;
580 IrpContext->Stack->Parameters.Read.ByteOffset.QuadPart += FatInfo->dataStart * FatInfo->BytesPerSector;
581 IoSkipCurrentIrpStackLocation(IrpContext->Irp);
582 IrpContext->Flags &= ~IRPCONTEXT_COMPLETE;
583 DPRINT("Read from page file, disk offset %I64x\n", IrpContext->Stack->Parameters.Read.ByteOffset.QuadPart);
584 Status = IoCallDriver(IrpContext->DeviceExt->StorageDevice, IrpContext->Irp);
585 return Status;
586 }
587
588 DPRINT("<%wZ>\n", &Fcb->PathNameU);
589
590 ByteOffset = IrpContext->Stack->Parameters.Read.ByteOffset;
591 Length = IrpContext->Stack->Parameters.Read.Length;
592 BytesPerSector = IrpContext->DeviceExt->FatInfo.BytesPerSector;
593
594 /* fail if file is a directory and no paged read */
595 if (vfatFCBIsDirectory(Fcb) && !PagingIo)
596 {
597 Status = STATUS_INVALID_PARAMETER;
598 goto ByeBye;
599 }
600
601 DPRINT("'%wZ', Offset: %u, Length %u\n", &Fcb->PathNameU, ByteOffset.u.LowPart, Length);
602
603 if (ByteOffset.u.HighPart && !IsVolume)
604 {
605 Status = STATUS_INVALID_PARAMETER;
606 goto ByeBye;
607 }
608
609 if (Length == 0)
610 {
611 IrpContext->Irp->IoStatus.Information = 0;
612 Status = STATUS_SUCCESS;
613 goto ByeBye;
614 }
615
616 if (ByteOffset.QuadPart >= Fcb->RFCB.FileSize.QuadPart)
617 {
618 IrpContext->Irp->IoStatus.Information = 0;
619 Status = STATUS_END_OF_FILE;
620 goto ByeBye;
621 }
622
623 if (NoCache || PagingIo || IsVolume)
624 {
625 if (ByteOffset.u.LowPart % BytesPerSector != 0 || Length % BytesPerSector != 0)
626 {
627 DPRINT("%u %u\n", ByteOffset.u.LowPart, Length);
628 // non cached read must be sector aligned
629 Status = STATUS_INVALID_PARAMETER;
630 goto ByeBye;
631 }
632 }
633
634 if (IsVolume)
635 {
636 Resource = &IrpContext->DeviceExt->DirResource;
637 }
638 else if (PagingIo)
639 {
640 Resource = &Fcb->PagingIoResource;
641 }
642 else
643 {
644 Resource = &Fcb->MainResource;
645 }
646
647 if (!ExAcquireResourceSharedLite(Resource, CanWait))
648 {
649 Resource = NULL;
650 Status = STATUS_PENDING;
651 goto ByeBye;
652 }
653
654 if (!PagingIo &&
655 FsRtlAreThereCurrentFileLocks(&Fcb->FileLock))
656 {
657 if (!FsRtlCheckLockForReadAccess(&Fcb->FileLock, IrpContext->Irp))
658 {
659 Status = STATUS_FILE_LOCK_CONFLICT;
660 goto ByeBye;
661 }
662 }
663
664 Buffer = VfatGetUserBuffer(IrpContext->Irp, PagingIo);
665
666 if (!PagingIo && !NoCache && !IsVolume)
667 {
668 // cached read
669 Status = STATUS_SUCCESS;
670 if (ByteOffset.u.LowPart + Length > Fcb->RFCB.FileSize.u.LowPart)
671 {
672 Length = Fcb->RFCB.FileSize.u.LowPart - ByteOffset.u.LowPart;
673 Status = /*STATUS_END_OF_FILE*/STATUS_SUCCESS;
674 }
675
676 vfatAddToStat(IrpContext->DeviceExt, Base.UserFileReads, 1);
677 vfatAddToStat(IrpContext->DeviceExt, Base.UserFileReadBytes, Length);
678
679 _SEH2_TRY
680 {
681 if (IrpContext->FileObject->PrivateCacheMap == NULL)
682 {
683 CcInitializeCacheMap(IrpContext->FileObject,
684 (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
685 FALSE,
686 &(VfatGlobalData->CacheMgrCallbacks),
687 Fcb);
688 }
689
690 if (!CcCopyRead(IrpContext->FileObject,
691 &ByteOffset,
692 Length,
693 CanWait,
694 Buffer,
695 &IrpContext->Irp->IoStatus))
696 {
697 ASSERT(!CanWait);
698 Status = STATUS_PENDING;
699 goto ByeBye;
700 }
701 }
702 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
703 {
704 Status = _SEH2_GetExceptionCode();
705 goto ByeBye;
706 }
707 _SEH2_END;
708
709 if (!NT_SUCCESS(IrpContext->Irp->IoStatus.Status))
710 {
711 Status = IrpContext->Irp->IoStatus.Status;
712 }
713 }
714 else
715 {
716 // non cached read
717 Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoWriteAccess);
718 if (!NT_SUCCESS(Status))
719 {
720 goto ByeBye;
721 }
722
723 if (ByteOffset.QuadPart + Length > ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector))
724 {
725 Length = (ULONG)(ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector) - ByteOffset.QuadPart);
726 }
727
728 if (!IsVolume)
729 {
730 vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedReads, 1);
731 vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedReadBytes, Length);
732 }
733 else
734 {
735 vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataReads, 1);
736 vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataReadBytes, Length);
737 }
738
739 Status = VfatReadFileData(IrpContext, Length, ByteOffset, &ReturnedLength);
740 if (NT_SUCCESS(Status))
741 {
742 IrpContext->Irp->IoStatus.Information = ReturnedLength;
743 }
744 }
745
746 ByeBye:
747 if (Resource)
748 {
749 ExReleaseResourceLite(Resource);
750 }
751
752 if (Status == STATUS_PENDING)
753 {
754 Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoWriteAccess);
755 if (NT_SUCCESS(Status))
756 {
757 Status = VfatMarkIrpContextForQueue(IrpContext);
758 }
759 }
760 else
761 {
762 IrpContext->Irp->IoStatus.Status = Status;
763 if (BooleanFlagOn(IrpContext->FileObject->Flags, FO_SYNCHRONOUS_IO) &&
764 !PagingIo &&
765 (NT_SUCCESS(Status) || Status == STATUS_END_OF_FILE))
766 {
767 IrpContext->FileObject->CurrentByteOffset.QuadPart =
768 ByteOffset.QuadPart + IrpContext->Irp->IoStatus.Information;
769 }
770
771 if (NT_SUCCESS(Status))
772 IrpContext->PriorityBoost = IO_DISK_INCREMENT;
773 }
774 DPRINT("%x\n", Status);
775 return Status;
776 }
777
778 NTSTATUS
779 VfatWrite(
780 PVFAT_IRP_CONTEXT IrpContext)
781 {
782 PVFATFCB Fcb;
783 PERESOURCE Resource = NULL;
784 LARGE_INTEGER ByteOffset;
785 LARGE_INTEGER OldFileSize;
786 NTSTATUS Status = STATUS_SUCCESS;
787 ULONG Length = 0;
788 PVOID Buffer;
789 ULONG BytesPerSector;
790 BOOLEAN PagingIo, CanWait, IsVolume, IsFAT, NoCache;
791
792 ASSERT(IrpContext);
793
794 DPRINT("VfatWrite(IrpContext %p)\n", IrpContext);
795
796 ASSERT(IrpContext->DeviceObject);
797
798 PagingIo = BooleanFlagOn(IrpContext->Irp->Flags, IRP_PAGING_IO);
799 CanWait = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT);
800 NoCache = BooleanFlagOn(IrpContext->Irp->Flags, IRP_NOCACHE);
801
802 // This request is not allowed on the main device object
803 if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
804 {
805 DPRINT("VfatWrite is called with the main device object.\n");
806 Status = STATUS_INVALID_DEVICE_REQUEST;
807 goto ByeBye;
808 }
809
810 ASSERT(IrpContext->DeviceExt);
811 ASSERT(IrpContext->FileObject);
812 Fcb = IrpContext->FileObject->FsContext;
813 ASSERT(Fcb);
814
815 IsVolume = BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME);
816 IsFAT = BooleanFlagOn(Fcb->Flags, FCB_IS_FAT);
817
818 if (BooleanFlagOn(Fcb->Flags, FCB_IS_PAGE_FILE))
819 {
820 PFATINFO FatInfo = &IrpContext->DeviceExt->FatInfo;
821 IrpContext->Stack->Parameters.Write.ByteOffset.QuadPart += FatInfo->dataStart * FatInfo->BytesPerSector;
822 IoSkipCurrentIrpStackLocation(IrpContext->Irp);
823 IrpContext->Flags &= ~IRPCONTEXT_COMPLETE;
824 DPRINT("Write to page file, disk offset %I64x\n", IrpContext->Stack->Parameters.Write.ByteOffset.QuadPart);
825 Status = IoCallDriver(IrpContext->DeviceExt->StorageDevice, IrpContext->Irp);
826 return Status;
827 }
828
829 DPRINT("<%wZ>\n", &Fcb->PathNameU);
830
831 /* fail if file is a directory and no paged read */
832 if (vfatFCBIsDirectory(Fcb) && !PagingIo)
833 {
834 Status = STATUS_INVALID_PARAMETER;
835 goto ByeBye;
836 }
837
838 ByteOffset = IrpContext->Stack->Parameters.Write.ByteOffset;
839 if (ByteOffset.u.LowPart == FILE_WRITE_TO_END_OF_FILE &&
840 ByteOffset.u.HighPart == -1)
841 {
842 ByteOffset.QuadPart = Fcb->RFCB.FileSize.QuadPart;
843 }
844 Length = IrpContext->Stack->Parameters.Write.Length;
845 BytesPerSector = IrpContext->DeviceExt->FatInfo.BytesPerSector;
846
847 if (ByteOffset.u.HighPart && !IsVolume)
848 {
849 Status = STATUS_INVALID_PARAMETER;
850 goto ByeBye;
851 }
852
853 if (IsFAT || IsVolume ||
854 vfatDirEntryGetFirstCluster(IrpContext->DeviceExt, &Fcb->entry) == 1)
855 {
856 if (ByteOffset.QuadPart + Length > Fcb->RFCB.FileSize.QuadPart)
857 {
858 // we can't extend the FAT, the volume or the root on FAT12/FAT16
859 Status = STATUS_END_OF_FILE;
860 goto ByeBye;
861 }
862 }
863
864 if (PagingIo || NoCache || IsVolume)
865 {
866 if (ByteOffset.u.LowPart % BytesPerSector != 0 || Length % BytesPerSector != 0)
867 {
868 // non cached write must be sector aligned
869 Status = STATUS_INVALID_PARAMETER;
870 goto ByeBye;
871 }
872 }
873
874 OldFileSize = Fcb->RFCB.FileSize;
875
876 if (Length == 0)
877 {
878 /* Update last write time */
879 IrpContext->Irp->IoStatus.Information = 0;
880 Status = STATUS_SUCCESS;
881 goto Metadata;
882 }
883
884 if (PagingIo)
885 {
886 if (ByteOffset.u.LowPart + Length > Fcb->RFCB.AllocationSize.u.LowPart)
887 {
888 Status = STATUS_INVALID_PARAMETER;
889 goto ByeBye;
890 }
891
892 if (ByteOffset.u.LowPart + Length > ROUND_UP(Fcb->RFCB.AllocationSize.u.LowPart, BytesPerSector))
893 {
894 Length = ROUND_UP(Fcb->RFCB.FileSize.u.LowPart, BytesPerSector) - ByteOffset.u.LowPart;
895 }
896 }
897
898 if (IsVolume)
899 {
900 Resource = &IrpContext->DeviceExt->DirResource;
901 }
902 else if (PagingIo)
903 {
904 Resource = &Fcb->PagingIoResource;
905 }
906 else
907 {
908 Resource = &Fcb->MainResource;
909 }
910
911 if (PagingIo)
912 {
913 if (!ExAcquireResourceSharedLite(Resource, CanWait))
914 {
915 Resource = NULL;
916 Status = STATUS_PENDING;
917 goto ByeBye;
918 }
919 }
920 else
921 {
922 if (!ExAcquireResourceExclusiveLite(Resource, CanWait))
923 {
924 Resource = NULL;
925 Status = STATUS_PENDING;
926 goto ByeBye;
927 }
928 }
929
930 if (!PagingIo &&
931 FsRtlAreThereCurrentFileLocks(&Fcb->FileLock))
932 {
933 if (!FsRtlCheckLockForWriteAccess(&Fcb->FileLock, IrpContext->Irp))
934 {
935 Status = STATUS_FILE_LOCK_CONFLICT;
936 goto ByeBye;
937 }
938 }
939
940 if (!CanWait && !IsVolume)
941 {
942 if (ByteOffset.u.LowPart + Length > Fcb->RFCB.AllocationSize.u.LowPart)
943 {
944 Status = STATUS_PENDING;
945 goto ByeBye;
946 }
947 }
948
949 Buffer = VfatGetUserBuffer(IrpContext->Irp, PagingIo);
950
951 if (!IsFAT && !IsVolume && !PagingIo &&
952 ByteOffset.u.LowPart + Length > Fcb->RFCB.FileSize.u.LowPart)
953 {
954 LARGE_INTEGER AllocationSize;
955 AllocationSize.QuadPart = ByteOffset.u.LowPart + Length;
956 Status = VfatSetAllocationSizeInformation(IrpContext->FileObject, Fcb,
957 IrpContext->DeviceExt, &AllocationSize);
958 if (!NT_SUCCESS (Status))
959 {
960 goto ByeBye;
961 }
962 }
963
964 if (!NoCache && !PagingIo && !IsVolume)
965 {
966 // cached write
967
968 vfatAddToStat(IrpContext->DeviceExt, Base.UserFileWrites, 1);
969 vfatAddToStat(IrpContext->DeviceExt, Base.UserFileWriteBytes, Length);
970
971 _SEH2_TRY
972 {
973 if (IrpContext->FileObject->PrivateCacheMap == NULL)
974 {
975 CcInitializeCacheMap(IrpContext->FileObject,
976 (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
977 FALSE,
978 &VfatGlobalData->CacheMgrCallbacks,
979 Fcb);
980 }
981
982 if (ByteOffset.QuadPart > OldFileSize.QuadPart)
983 {
984 CcZeroData(IrpContext->FileObject, &OldFileSize, &ByteOffset, TRUE);
985 }
986
987 if (CcCopyWrite(IrpContext->FileObject,
988 &ByteOffset,
989 Length,
990 TRUE /*CanWait*/,
991 Buffer))
992 {
993 IrpContext->Irp->IoStatus.Information = Length;
994 Status = STATUS_SUCCESS;
995 }
996 else
997 {
998 ASSERT(FALSE /*!CanWait*/);
999 Status = STATUS_UNSUCCESSFUL;
1000 }
1001 }
1002 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1003 {
1004 Status = _SEH2_GetExceptionCode();
1005 }
1006 _SEH2_END;
1007 }
1008 else
1009 {
1010 // non cached write
1011 Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoReadAccess);
1012 if (!NT_SUCCESS(Status))
1013 {
1014 Status = STATUS_INVALID_USER_BUFFER;
1015 goto ByeBye;
1016 }
1017
1018 if (ByteOffset.QuadPart > OldFileSize.QuadPart)
1019 {
1020 CcZeroData(IrpContext->FileObject, &OldFileSize, &ByteOffset, TRUE);
1021 }
1022
1023 if (!IsVolume)
1024 {
1025 vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedWrites, 1);
1026 vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedWriteBytes, Length);
1027 }
1028 else
1029 {
1030 vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataWrites, 1);
1031 vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataWriteBytes, Length);
1032 }
1033
1034 Status = VfatWriteFileData(IrpContext, Length, ByteOffset);
1035 if (NT_SUCCESS(Status))
1036 {
1037 IrpContext->Irp->IoStatus.Information = Length;
1038 }
1039 }
1040
1041 Metadata:
1042 if (!PagingIo && !IsFAT && !IsVolume)
1043 {
1044 if(!vfatFCBIsDirectory(Fcb))
1045 {
1046 LARGE_INTEGER SystemTime;
1047 ULONG Filter;
1048
1049 // set dates and times
1050 KeQuerySystemTime (&SystemTime);
1051 if (vfatVolumeIsFatX(IrpContext->DeviceExt))
1052 {
1053 FsdSystemTimeToDosDateTime(IrpContext->DeviceExt,
1054 &SystemTime, &Fcb->entry.FatX.UpdateDate,
1055 &Fcb->entry.FatX.UpdateTime);
1056 Fcb->entry.FatX.AccessDate = Fcb->entry.FatX.UpdateDate;
1057 Fcb->entry.FatX.AccessTime = Fcb->entry.FatX.UpdateTime;
1058 }
1059 else
1060 {
1061 FsdSystemTimeToDosDateTime(IrpContext->DeviceExt,
1062 &SystemTime, &Fcb->entry.Fat.UpdateDate,
1063 &Fcb->entry.Fat.UpdateTime);
1064 Fcb->entry.Fat.AccessDate = Fcb->entry.Fat.UpdateDate;
1065 }
1066 /* set date and times to dirty */
1067 Fcb->Flags |= FCB_IS_DIRTY;
1068
1069 /* Time to notify the OS */
1070 Filter = FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_ATTRIBUTES;
1071 if (ByteOffset.QuadPart != OldFileSize.QuadPart) Filter |= FILE_NOTIFY_CHANGE_SIZE;
1072
1073 FsRtlNotifyFullReportChange(IrpContext->DeviceExt->NotifySync,
1074 &(IrpContext->DeviceExt->NotifyList),
1075 (PSTRING)&Fcb->PathNameU,
1076 Fcb->PathNameU.Length - Fcb->LongNameU.Length,
1077 NULL,
1078 NULL,
1079 Filter,
1080 FILE_ACTION_MODIFIED,
1081 NULL);
1082 }
1083 }
1084
1085 ByeBye:
1086 if (Resource)
1087 {
1088 ExReleaseResourceLite(Resource);
1089 }
1090
1091 if (Status == STATUS_PENDING)
1092 {
1093 Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoReadAccess);
1094 if (NT_SUCCESS(Status))
1095 {
1096 Status = VfatMarkIrpContextForQueue(IrpContext);
1097 }
1098 }
1099 else
1100 {
1101 IrpContext->Irp->IoStatus.Status = Status;
1102 if (BooleanFlagOn(IrpContext->FileObject->Flags, FO_SYNCHRONOUS_IO) &&
1103 !PagingIo && NT_SUCCESS(Status))
1104 {
1105 IrpContext->FileObject->CurrentByteOffset.QuadPart =
1106 ByteOffset.QuadPart + IrpContext->Irp->IoStatus.Information;
1107 }
1108
1109 if (NT_SUCCESS(Status))
1110 IrpContext->PriorityBoost = IO_DISK_INCREMENT;
1111 }
1112 DPRINT("%x\n", Status);
1113 return Status;
1114 }