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