9dcddea16e502f6f37f6edca6a3dfb997cdd02e2
[reactos.git] / reactos / 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 // This request is not allowed on the main device object
559 if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
560 {
561 DPRINT("VfatRead is called with the main device object.\n");
562 Status = STATUS_INVALID_DEVICE_REQUEST;
563 goto ByeBye;
564 }
565
566 ASSERT(IrpContext->DeviceExt);
567 ASSERT(IrpContext->FileObject);
568 Fcb = IrpContext->FileObject->FsContext;
569 ASSERT(Fcb);
570
571 if (BooleanFlagOn(Fcb->Flags, FCB_IS_PAGE_FILE))
572 {
573 PFATINFO FatInfo = &IrpContext->DeviceExt->FatInfo;
574 IrpContext->Stack->Parameters.Read.ByteOffset.QuadPart += FatInfo->dataStart * FatInfo->BytesPerSector;
575 IoSkipCurrentIrpStackLocation(IrpContext->Irp);
576 IrpContext->Flags &= ~IRPCONTEXT_COMPLETE;
577 DPRINT("Read from page file, disk offset %I64x\n", IrpContext->Stack->Parameters.Read.ByteOffset.QuadPart);
578 Status = IoCallDriver(IrpContext->DeviceExt->StorageDevice, IrpContext->Irp);
579 return Status;
580 }
581
582 DPRINT("<%wZ>\n", &Fcb->PathNameU);
583
584 ByteOffset = IrpContext->Stack->Parameters.Read.ByteOffset;
585 Length = IrpContext->Stack->Parameters.Read.Length;
586 BytesPerSector = IrpContext->DeviceExt->FatInfo.BytesPerSector;
587 PagingIo = BooleanFlagOn(IrpContext->Irp->Flags, IRP_PAGING_IO);
588 CanWait = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT);
589 IsVolume = BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME);
590 NoCache = BooleanFlagOn(IrpContext->Irp->Flags, IRP_NOCACHE);
591
592 /* fail if file is a directory and no paged read */
593 if (vfatFCBIsDirectory(Fcb) && !PagingIo)
594 {
595 Status = STATUS_INVALID_PARAMETER;
596 goto ByeBye;
597 }
598
599 DPRINT("'%wZ', Offset: %u, Length %u\n", &Fcb->PathNameU, ByteOffset.u.LowPart, Length);
600
601 if (ByteOffset.u.HighPart && !IsVolume)
602 {
603 Status = STATUS_INVALID_PARAMETER;
604 goto ByeBye;
605 }
606
607 if (Length == 0)
608 {
609 IrpContext->Irp->IoStatus.Information = 0;
610 Status = STATUS_SUCCESS;
611 goto ByeBye;
612 }
613
614 if (ByteOffset.QuadPart >= Fcb->RFCB.FileSize.QuadPart)
615 {
616 IrpContext->Irp->IoStatus.Information = 0;
617 Status = STATUS_END_OF_FILE;
618 goto ByeBye;
619 }
620
621 if (NoCache || PagingIo || IsVolume)
622 {
623 if (ByteOffset.u.LowPart % BytesPerSector != 0 || Length % BytesPerSector != 0)
624 {
625 DPRINT("%u %u\n", ByteOffset.u.LowPart, Length);
626 // non cached read must be sector aligned
627 Status = STATUS_INVALID_PARAMETER;
628 goto ByeBye;
629 }
630 }
631
632 if (IsVolume)
633 {
634 Resource = &IrpContext->DeviceExt->DirResource;
635 }
636 else if (PagingIo)
637 {
638 Resource = &Fcb->PagingIoResource;
639 }
640 else
641 {
642 Resource = &Fcb->MainResource;
643 }
644
645 if (!ExAcquireResourceSharedLite(Resource, CanWait))
646 {
647 Resource = NULL;
648 Status = STATUS_PENDING;
649 goto ByeBye;
650 }
651
652 if (!PagingIo &&
653 FsRtlAreThereCurrentFileLocks(&Fcb->FileLock))
654 {
655 if (!FsRtlCheckLockForReadAccess(&Fcb->FileLock, IrpContext->Irp))
656 {
657 Status = STATUS_FILE_LOCK_CONFLICT;
658 goto ByeBye;
659 }
660 }
661
662 Buffer = VfatGetUserBuffer(IrpContext->Irp, PagingIo);
663
664 if (!PagingIo && !NoCache && !IsVolume)
665 {
666 // cached read
667 Status = STATUS_SUCCESS;
668 if (ByteOffset.u.LowPart + Length > Fcb->RFCB.FileSize.u.LowPart)
669 {
670 Length = Fcb->RFCB.FileSize.u.LowPart - ByteOffset.u.LowPart;
671 Status = /*STATUS_END_OF_FILE*/STATUS_SUCCESS;
672 }
673
674 _SEH2_TRY
675 {
676 if (IrpContext->FileObject->PrivateCacheMap == NULL)
677 {
678 CcInitializeCacheMap(IrpContext->FileObject,
679 (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
680 FALSE,
681 &(VfatGlobalData->CacheMgrCallbacks),
682 Fcb);
683 }
684
685 if (!CcCopyRead(IrpContext->FileObject,
686 &ByteOffset,
687 Length,
688 CanWait,
689 Buffer,
690 &IrpContext->Irp->IoStatus))
691 {
692 ASSERT(!CanWait);
693 Status = STATUS_PENDING;
694 goto ByeBye;
695 }
696 }
697 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
698 {
699 Status = _SEH2_GetExceptionCode();
700 goto ByeBye;
701 }
702 _SEH2_END;
703
704 if (!NT_SUCCESS(IrpContext->Irp->IoStatus.Status))
705 {
706 Status = IrpContext->Irp->IoStatus.Status;
707 }
708 }
709 else
710 {
711 // non cached read
712 Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoWriteAccess);
713 if (!NT_SUCCESS(Status))
714 {
715 goto ByeBye;
716 }
717
718 if (ByteOffset.QuadPart + Length > ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector))
719 {
720 Length = (ULONG)(ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector) - ByteOffset.QuadPart);
721 }
722
723 Status = VfatReadFileData(IrpContext, Length, ByteOffset, &ReturnedLength);
724 if (NT_SUCCESS(Status))
725 {
726 IrpContext->Irp->IoStatus.Information = ReturnedLength;
727 }
728 }
729
730 ByeBye:
731 if (Resource)
732 {
733 ExReleaseResourceLite(Resource);
734 }
735
736 if (Status == STATUS_PENDING)
737 {
738 Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoWriteAccess);
739 if (NT_SUCCESS(Status))
740 {
741 Status = VfatMarkIrpContextForQueue(IrpContext);
742 }
743 }
744 else
745 {
746 IrpContext->Irp->IoStatus.Status = Status;
747 if (BooleanFlagOn(IrpContext->FileObject->Flags, FO_SYNCHRONOUS_IO) &&
748 !PagingIo &&
749 (NT_SUCCESS(Status) || Status == STATUS_END_OF_FILE))
750 {
751 IrpContext->FileObject->CurrentByteOffset.QuadPart =
752 ByteOffset.QuadPart + IrpContext->Irp->IoStatus.Information;
753 }
754
755 if (NT_SUCCESS(Status))
756 IrpContext->PriorityBoost = IO_DISK_INCREMENT;
757 }
758 DPRINT("%x\n", Status);
759 return Status;
760 }
761
762 NTSTATUS
763 VfatWrite(
764 PVFAT_IRP_CONTEXT IrpContext)
765 {
766 PVFATFCB Fcb;
767 PERESOURCE Resource = NULL;
768 LARGE_INTEGER ByteOffset;
769 LARGE_INTEGER OldFileSize;
770 NTSTATUS Status = STATUS_SUCCESS;
771 ULONG Length = 0;
772 PVOID Buffer;
773 ULONG BytesPerSector;
774 BOOLEAN PagingIo, CanWait, IsVolume, IsFAT, NoCache;
775
776 ASSERT(IrpContext);
777
778 DPRINT("VfatWrite(IrpContext %p)\n", IrpContext);
779
780 ASSERT(IrpContext->DeviceObject);
781
782 // This request is not allowed on the main device object
783 if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
784 {
785 DPRINT("VfatWrite is called with the main device object.\n");
786 Status = STATUS_INVALID_DEVICE_REQUEST;
787 goto ByeBye;
788 }
789
790 ASSERT(IrpContext->DeviceExt);
791 ASSERT(IrpContext->FileObject);
792 Fcb = IrpContext->FileObject->FsContext;
793 ASSERT(Fcb);
794
795 if (BooleanFlagOn(Fcb->Flags, FCB_IS_PAGE_FILE))
796 {
797 PFATINFO FatInfo = &IrpContext->DeviceExt->FatInfo;
798 IrpContext->Stack->Parameters.Write.ByteOffset.QuadPart += FatInfo->dataStart * FatInfo->BytesPerSector;
799 IoSkipCurrentIrpStackLocation(IrpContext->Irp);
800 IrpContext->Flags &= ~IRPCONTEXT_COMPLETE;
801 DPRINT("Write to page file, disk offset %I64x\n", IrpContext->Stack->Parameters.Write.ByteOffset.QuadPart);
802 Status = IoCallDriver(IrpContext->DeviceExt->StorageDevice, IrpContext->Irp);
803 return Status;
804 }
805
806 DPRINT("<%wZ>\n", &Fcb->PathNameU);
807
808 PagingIo = BooleanFlagOn(IrpContext->Irp->Flags, IRP_PAGING_IO);
809 CanWait = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT);
810 IsVolume = BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME);
811 IsFAT = BooleanFlagOn(Fcb->Flags, FCB_IS_FAT);
812 NoCache = BooleanFlagOn(IrpContext->Irp->Flags, IRP_NOCACHE);
813
814 /* fail if file is a directory and no paged read */
815 if (vfatFCBIsDirectory(Fcb) && !PagingIo)
816 {
817 Status = STATUS_INVALID_PARAMETER;
818 goto ByeBye;
819 }
820
821 ByteOffset = IrpContext->Stack->Parameters.Write.ByteOffset;
822 if (ByteOffset.u.LowPart == FILE_WRITE_TO_END_OF_FILE &&
823 ByteOffset.u.HighPart == -1)
824 {
825 ByteOffset.QuadPart = Fcb->RFCB.FileSize.QuadPart;
826 }
827 Length = IrpContext->Stack->Parameters.Write.Length;
828 BytesPerSector = IrpContext->DeviceExt->FatInfo.BytesPerSector;
829
830 if (ByteOffset.u.HighPart && !IsVolume)
831 {
832 Status = STATUS_INVALID_PARAMETER;
833 goto ByeBye;
834 }
835
836 if (IsFAT || IsVolume ||
837 vfatDirEntryGetFirstCluster(IrpContext->DeviceExt, &Fcb->entry) == 1)
838 {
839 if (ByteOffset.QuadPart + Length > Fcb->RFCB.FileSize.QuadPart)
840 {
841 // we can't extend the FAT, the volume or the root on FAT12/FAT16
842 Status = STATUS_END_OF_FILE;
843 goto ByeBye;
844 }
845 }
846
847 if (PagingIo || NoCache || IsVolume)
848 {
849 if (ByteOffset.u.LowPart % BytesPerSector != 0 || Length % BytesPerSector != 0)
850 {
851 // non cached write must be sector aligned
852 Status = STATUS_INVALID_PARAMETER;
853 goto ByeBye;
854 }
855 }
856
857 OldFileSize = Fcb->RFCB.FileSize;
858
859 if (Length == 0)
860 {
861 /* Update last write time */
862 IrpContext->Irp->IoStatus.Information = 0;
863 Status = STATUS_SUCCESS;
864 goto Metadata;
865 }
866
867 if (PagingIo)
868 {
869 if (ByteOffset.u.LowPart + Length > Fcb->RFCB.AllocationSize.u.LowPart)
870 {
871 Status = STATUS_INVALID_PARAMETER;
872 goto ByeBye;
873 }
874
875 if (ByteOffset.u.LowPart + Length > ROUND_UP(Fcb->RFCB.AllocationSize.u.LowPart, BytesPerSector))
876 {
877 Length = ROUND_UP(Fcb->RFCB.FileSize.u.LowPart, BytesPerSector) - ByteOffset.u.LowPart;
878 }
879 }
880
881 if (IsVolume)
882 {
883 Resource = &IrpContext->DeviceExt->DirResource;
884 }
885 else if (PagingIo)
886 {
887 Resource = &Fcb->PagingIoResource;
888 }
889 else
890 {
891 Resource = &Fcb->MainResource;
892 }
893
894 if (PagingIo)
895 {
896 if (!ExAcquireResourceSharedLite(Resource, CanWait))
897 {
898 Resource = NULL;
899 Status = STATUS_PENDING;
900 goto ByeBye;
901 }
902 }
903 else
904 {
905 if (!ExAcquireResourceExclusiveLite(Resource, CanWait))
906 {
907 Resource = NULL;
908 Status = STATUS_PENDING;
909 goto ByeBye;
910 }
911 }
912
913 if (!PagingIo &&
914 FsRtlAreThereCurrentFileLocks(&Fcb->FileLock))
915 {
916 if (!FsRtlCheckLockForWriteAccess(&Fcb->FileLock, IrpContext->Irp))
917 {
918 Status = STATUS_FILE_LOCK_CONFLICT;
919 goto ByeBye;
920 }
921 }
922
923 if (!CanWait && !IsVolume)
924 {
925 if (ByteOffset.u.LowPart + Length > Fcb->RFCB.AllocationSize.u.LowPart)
926 {
927 Status = STATUS_PENDING;
928 goto ByeBye;
929 }
930 }
931
932 Buffer = VfatGetUserBuffer(IrpContext->Irp, PagingIo);
933
934 if (!IsFAT && !IsVolume && !PagingIo &&
935 ByteOffset.u.LowPart + Length > Fcb->RFCB.FileSize.u.LowPart)
936 {
937 LARGE_INTEGER AllocationSize;
938 AllocationSize.QuadPart = ByteOffset.u.LowPart + Length;
939 Status = VfatSetAllocationSizeInformation(IrpContext->FileObject, Fcb,
940 IrpContext->DeviceExt, &AllocationSize);
941 if (!NT_SUCCESS (Status))
942 {
943 goto ByeBye;
944 }
945 }
946
947 if (!NoCache && !PagingIo && !IsVolume)
948 {
949 // cached write
950
951 _SEH2_TRY
952 {
953 if (IrpContext->FileObject->PrivateCacheMap == NULL)
954 {
955 CcInitializeCacheMap(IrpContext->FileObject,
956 (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
957 FALSE,
958 &VfatGlobalData->CacheMgrCallbacks,
959 Fcb);
960 }
961
962 if (ByteOffset.QuadPart > OldFileSize.QuadPart)
963 {
964 CcZeroData(IrpContext->FileObject, &OldFileSize, &ByteOffset, TRUE);
965 }
966
967 if (CcCopyWrite(IrpContext->FileObject,
968 &ByteOffset,
969 Length,
970 TRUE /*CanWait*/,
971 Buffer))
972 {
973 IrpContext->Irp->IoStatus.Information = Length;
974 Status = STATUS_SUCCESS;
975 }
976 else
977 {
978 ASSERT(FALSE /*!CanWait*/);
979 Status = STATUS_UNSUCCESSFUL;
980 }
981 }
982 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
983 {
984 Status = _SEH2_GetExceptionCode();
985 }
986 _SEH2_END;
987 }
988 else
989 {
990 // non cached write
991 Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoReadAccess);
992 if (!NT_SUCCESS(Status))
993 {
994 Status = STATUS_INVALID_USER_BUFFER;
995 goto ByeBye;
996 }
997
998 if (ByteOffset.QuadPart > OldFileSize.QuadPart)
999 {
1000 CcZeroData(IrpContext->FileObject, &OldFileSize, &ByteOffset, TRUE);
1001 }
1002
1003 Status = VfatWriteFileData(IrpContext, Length, ByteOffset);
1004 if (NT_SUCCESS(Status))
1005 {
1006 IrpContext->Irp->IoStatus.Information = Length;
1007 }
1008 }
1009
1010 Metadata:
1011 if (!PagingIo && !IsFAT && !IsVolume)
1012 {
1013 if(!vfatFCBIsDirectory(Fcb))
1014 {
1015 LARGE_INTEGER SystemTime;
1016 ULONG Filter;
1017
1018 // set dates and times
1019 KeQuerySystemTime (&SystemTime);
1020 if (vfatVolumeIsFatX(IrpContext->DeviceExt))
1021 {
1022 FsdSystemTimeToDosDateTime(IrpContext->DeviceExt,
1023 &SystemTime, &Fcb->entry.FatX.UpdateDate,
1024 &Fcb->entry.FatX.UpdateTime);
1025 Fcb->entry.FatX.AccessDate = Fcb->entry.FatX.UpdateDate;
1026 Fcb->entry.FatX.AccessTime = Fcb->entry.FatX.UpdateTime;
1027 }
1028 else
1029 {
1030 FsdSystemTimeToDosDateTime(IrpContext->DeviceExt,
1031 &SystemTime, &Fcb->entry.Fat.UpdateDate,
1032 &Fcb->entry.Fat.UpdateTime);
1033 Fcb->entry.Fat.AccessDate = Fcb->entry.Fat.UpdateDate;
1034 }
1035 /* set date and times to dirty */
1036 Fcb->Flags |= FCB_IS_DIRTY;
1037
1038 /* Time to notify the OS */
1039 Filter = FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_ATTRIBUTES;
1040 if (ByteOffset.QuadPart != OldFileSize.QuadPart) Filter |= FILE_NOTIFY_CHANGE_SIZE;
1041
1042 FsRtlNotifyFullReportChange(IrpContext->DeviceExt->NotifySync,
1043 &(IrpContext->DeviceExt->NotifyList),
1044 (PSTRING)&Fcb->PathNameU,
1045 Fcb->PathNameU.Length - Fcb->LongNameU.Length,
1046 NULL,
1047 NULL,
1048 Filter,
1049 FILE_ACTION_MODIFIED,
1050 NULL);
1051 }
1052 }
1053
1054 ByeBye:
1055 if (Resource)
1056 {
1057 ExReleaseResourceLite(Resource);
1058 }
1059
1060 if (Status == STATUS_PENDING)
1061 {
1062 Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoReadAccess);
1063 if (NT_SUCCESS(Status))
1064 {
1065 Status = VfatMarkIrpContextForQueue(IrpContext);
1066 }
1067 }
1068 else
1069 {
1070 IrpContext->Irp->IoStatus.Status = Status;
1071 if (BooleanFlagOn(IrpContext->FileObject->Flags, FO_SYNCHRONOUS_IO) &&
1072 !PagingIo && NT_SUCCESS(Status))
1073 {
1074 IrpContext->FileObject->CurrentByteOffset.QuadPart =
1075 ByteOffset.QuadPart + IrpContext->Irp->IoStatus.Information;
1076 }
1077
1078 if (NT_SUCCESS(Status))
1079 IrpContext->PriorityBoost = IO_DISK_INCREMENT;
1080 }
1081 DPRINT("%x\n", Status);
1082 return Status;
1083 }