ReactOS  0.4.15-dev-1033-gd7d716a
verfysup.c File Reference
#include "fatprocs.h"
Include dependency graph for verfysup.c:

Go to the source code of this file.

Macros

#define BugCheckFileId   (FAT_BUG_CHECK_VERFYSUP)
 
#define Dbg   (DEBUG_TRACE_VERFYSUP)
 

Functions

VOID FatResetFcb (IN PIRP_CONTEXT IrpContext, IN PFCB Fcb)
 
BOOLEAN FatMatchFileSize (__in PIRP_CONTEXT IrpContext, __in PDIRENT Dirent, __in PFCB Fcb)
 
 _Requires_lock_held_ (_Global_critical_region_)
 
BOOLEAN FatMarkDevForVerifyIfVcbMounted (IN PVCB Vcb)
 
VOID FatVerifyVcb (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
 
VOID NTAPI FatDeferredCleanVolume (_In_ PVOID Parameter)
 
VOID NTAPI FatCleanVolumeDpc (_In_ PKDPC Dpc, _In_opt_ PVOID DeferredContext, _In_opt_ PVOID SystemArgument1, _In_opt_ PVOID SystemArgument2)
 
VOID NTAPI FatFspMarkVolumeDirtyWithRecover (PVOID Parameter)
 
VOID FatCheckDirtyBit (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
 
VOID FatVerifyOperationIsLegal (IN PIRP_CONTEXT IrpContext)
 
VOID FatQuickVerifyVcb (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
 
NTSTATUS NTAPI FatMarkVolumeCompletionRoutine (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Contxt)
 

Macro Definition Documentation

◆ BugCheckFileId

#define BugCheckFileId   (FAT_BUG_CHECK_VERFYSUP)

Definition at line 23 of file verfysup.c.

◆ Dbg

#define Dbg   (DEBUG_TRACE_VERFYSUP)

Definition at line 29 of file verfysup.c.

Function Documentation

◆ _Requires_lock_held_()

_Requires_lock_held_ ( _Global_critical_region_  )

Definition at line 48 of file verfysup.c.

119 {
120  PAGED_CODE();
121 
122  DebugTrace(+1, Dbg, "FatMarkFcbCondition, Fcb = %p\n", Fcb );
123 
124  //
125  // If we are marking this Fcb something other than Good, we will need
126  // to have the Vcb exclusive.
127  //
128 
129  NT_ASSERT( FcbCondition != FcbNeedsToBeVerified ? TRUE :
130  FatVcbAcquiredExclusive(IrpContext, Fcb->Vcb) );
131 
132  //
133  // If this is a PagingFile it has to be good unless media underneath is
134  // removable. The "removable" check was added specifically for ReadyBoost,
135  // which opens its cache file on a removable device as a paging file and
136  // relies on the file system to validate its mapping information after a
137  // power transition.
138  //
139 
142 
144  return;
145  }
146 
147  //
148  // Update the condition of the Fcb.
149  //
150 
151  Fcb->FcbCondition = FcbCondition;
152 
153  DebugTrace(0, Dbg, "MarkFcb: %wZ\n", &Fcb->FullFileName);
154 
155  //
156  // This FastIo flag is based on FcbCondition, so update it now. This only
157  // applies to regular FCBs, of course.
158  //
159 
160  if (Fcb->Header.NodeTypeCode == FAT_NTC_FCB) {
161 
162  Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
163  }
164 
165  if (FcbCondition == FcbNeedsToBeVerified) {
166  FatResetFcb( IrpContext, Fcb );
167  }
168 
169  //
170  // Now if we marked NeedsVerify or Bad a directory then we also need to
171  // go and mark all of our children with the same condition.
172  //
173 
174  if ( ((FcbCondition == FcbNeedsToBeVerified) ||
175  (FcbCondition == FcbBad)) &&
176  Recursive &&
177  ((Fcb->Header.NodeTypeCode == FAT_NTC_DCB) ||
178  (Fcb->Header.NodeTypeCode == FAT_NTC_ROOT_DCB)) ) {
179 
180  PFCB OriginalFcb = Fcb;
181 
182  while ( (Fcb = FatGetNextFcbTopDown(IrpContext, Fcb, OriginalFcb)) != NULL ) {
183 
184  DebugTrace(0, Dbg, "MarkFcb: %wZ\n", &Fcb->FullFileName);
185 
186  Fcb->FcbCondition = FcbCondition;
187 
188  //
189  // We already know that FastIo is not possible since we are propagating
190  // a parent's bad/verify flag down the tree - IO to the children must
191  // take the long route for now.
192  //
193 
194  Fcb->Header.IsFastIoPossible = FastIoIsNotPossible;
195 
196  //
197  // Leave all the Fcbs in a condition to be verified.
198  //
199 
200  if (FcbCondition == FcbNeedsToBeVerified) {
201  FatResetFcb( IrpContext, Fcb );
202  }
203 
204  }
205  }
206 
207  DebugTrace(-1, Dbg, "FatMarkFcbCondition -> VOID\n", 0);
208 
209  return;
210 }
FSRTL_ADVANCED_FCB_HEADER Header
Definition: cdstruc.h:931
#define TRUE
Definition: types.h:120
Definition: cdstruc.h:908
#define DebugTrace(INDENT, LEVEL, X, Y)
Definition: fatdata.h:313
ULONG VcbState
Definition: cdstruc.h:546
#define Dbg
Definition: verfysup.c:29
#define FCB_STATE_PAGING_FILE
Definition: fatstruc.h:1194
smooth NULL
Definition: ftsmooth.c:416
#define VCB_STATE_FLAG_REMOVABLE_MEDIA
Definition: fatstruc.h:559
VOID FatResetFcb(IN PIRP_CONTEXT IrpContext, IN PFCB Fcb)
Definition: verfysup.c:1396
UNICODE_STRING FullFileName
Definition: fatstruc.h:1121
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
#define FatIsFastIoPossible(FCB)
Definition: fatprocs.h:2810
#define FAT_NTC_ROOT_DCB
Definition: nodetype.h:31
#define FAT_NTC_DCB
Definition: nodetype.h:30
#define FatVcbAcquiredExclusive(IRPCONTEXT, VCB)
Definition: fatprocs.h:1495
PVCB Vcb
Definition: cdstruc.h:939
_In_ PFCB Fcb
Definition: cdprocs.h:159
ULONG FcbState
Definition: cdstruc.h:977
#define FAT_NTC_FCB
Definition: nodetype.h:29
#define PAGED_CODE()
#define NT_ASSERT
Definition: rtlfuncs.h:3312
PFCB FatGetNextFcbTopDown(IN PIRP_CONTEXT IrpContext, IN PFCB Fcb, IN PFCB TerminationFcb)
Definition: strucsup.c:2615
FCB_CONDITION FcbCondition
Definition: fatstruc.h:849

◆ FatCheckDirtyBit()

VOID FatCheckDirtyBit ( IN PIRP_CONTEXT  IrpContext,
IN PVCB  Vcb 
)

Definition at line 1185 of file verfysup.c.

1207 {
1208  BOOLEAN Dirty;
1209 
1211  PBCB BootSectorBcb;
1212 
1213  UNICODE_STRING VolumeLabel;
1214 
1215  PAGED_CODE();
1216 
1217  //
1218  // Look in the boot sector
1219  //
1220 
1221  FatReadVolumeFile( IrpContext,
1222  Vcb,
1223  0,
1224  sizeof(PACKED_BOOT_SECTOR),
1225  &BootSectorBcb,
1226  (PVOID *)&BootSector );
1227 
1228  _SEH2_TRY {
1229 
1230  //
1231  // Check if the magic bit is set
1232  //
1233 
1234  if (IsBpbFat32(&BootSector->PackedBpb)) {
1235  Dirty = BooleanFlagOn( ((PPACKED_BOOT_SECTOR_EX)BootSector)->CurrentHead,
1237  } else {
1238  Dirty = BooleanFlagOn( BootSector->CurrentHead, FAT_BOOT_SECTOR_DIRTY );
1239  }
1240 
1241  //
1242  // Setup the VolumeLabel string
1243  //
1244 
1245  VolumeLabel.Length = Vcb->Vpb->VolumeLabelLength;
1247  VolumeLabel.Buffer = &Vcb->Vpb->VolumeLabel[0];
1248 
1249  if ( Dirty ) {
1250 
1251  //
1252  // Do not trigger the mounted dirty bit if this is a verify
1253  // and the volume is a boot or paging device. We know that
1254  // a boot or paging device cannot leave the system, and thus
1255  // that on its mount we will have figured this out correctly.
1256  //
1257  // This logic is a reasonable change. Why?
1258  // 'cause setup cracked a non-exclusive DASD handle near the
1259  // end of setup, wrote some data, closed the handle and we
1260  // set the verify bit ... came back around and saw that other
1261  // arbitrary activity had left the volume in a temporarily dirty
1262  // state.
1263  //
1264  // Of course, the real problem is that we don't have a journal.
1265  //
1266 
1267  if (!(IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL &&
1268  IrpContext->MinorFunction == IRP_MN_VERIFY_VOLUME &&
1270 
1273  "FASTFAT: WARNING! Mounting Dirty Volume %Z\n",
1274  &VolumeLabel));
1275 
1277  }
1278 
1279  } else {
1280 
1281  if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY)) {
1282 
1285  "FASTFAT: Volume %Z has been cleaned.\n",
1286  &VolumeLabel));
1287 
1289 
1290  } else {
1291 
1292  (VOID)FsRtlBalanceReads( Vcb->TargetDeviceObject );
1293  }
1294  }
1295 
1296  } _SEH2_FINALLY {
1297 
1298  FatUnpinBcb( IrpContext, BootSectorBcb );
1299  } _SEH2_END;
1300 }
#define IsBpbFat32(bpb)
Definition: fat.h:101
#define VCB_STATE_FLAG_MOUNTED_DIRTY
Definition: fatstruc.h:561
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
#define FAT_BOOT_SECTOR_DIRTY
Definition: fat.h:213
#define DPFLTR_INFO_LEVEL
Definition: kdtypes.h:33
VOID FatReadVolumeFile(IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN VBO StartingVbo, IN ULONG ByteCount, OUT PBCB *Bcb, OUT PVOID *Buffer)
Definition: cachesup.c:102
_SEH2_TRY
Definition: create.c:4226
#define KdPrintEx(_x_)
Definition: kdfuncs.h:114
struct _BootSector BootSector
Definition: vfat.h:108
#define IRP_MN_VERIFY_VOLUME
Definition: iotypes.h:4056
#define FatUnpinBcb(IRPCONTEXT, BCB)
Definition: fatprocs.h:546
unsigned char BOOLEAN
#define MAXIMUM_VOLUME_LABEL_LENGTH
Definition: iotypes.h:156
#define VCB_STATE_FLAG_BOOT_OR_PAGING_FILE
Definition: fatstruc.h:566
NTSTATUS NTAPI FsRtlBalanceReads(PDEVICE_OBJECT TargetDevice)
Definition: faulttol.c:35
#define IRP_MJ_FILE_SYSTEM_CONTROL
#define Vcb
Definition: cdprocs.h:1415
#define VOID
Definition: acefi.h:82
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
ClearFlag(Dirent->Flags, DIRENT_FLAG_NOT_PERSISTENT)
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
_SEH2_END
Definition: create.c:4400
_SEH2_FINALLY
Definition: create.c:4371
#define PAGED_CODE()

◆ FatCleanVolumeDpc()

VOID NTAPI FatCleanVolumeDpc ( _In_ PKDPC  Dpc,
_In_opt_ PVOID  DeferredContext,
_In_opt_ PVOID  SystemArgument1,
_In_opt_ PVOID  SystemArgument2 
)

Definition at line 654 of file verfysup.c.

679 {
680  PVCB Vcb;
682 
686 
688 
689 
690  //
691  // If there is still dirty data (highly unlikely), set the timer for a
692  // second in the future.
693  //
694 
695  if (CcIsThereDirtyData(Vcb->Vpb)) {
696 
697  LARGE_INTEGER TwoSecondsFromNow;
698 
699  TwoSecondsFromNow.QuadPart = (LONG)-2*1000*1000*10;
700 
701  KeSetTimer( &Vcb->CleanVolumeTimer,
702  TwoSecondsFromNow,
703  &Vcb->CleanVolumeDpc );
704 
705  return;
706  }
707 
708  //
709  // If we couldn't get pool, oh well....
710  //
711 
712  Packet = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(CLEAN_AND_DIRTY_VOLUME_PACKET), ' taF');
713 
714  if ( Packet ) {
715 
716  Packet->Vcb = Vcb;
717  Packet->Irp = NULL;
718 
719  //
720  // Clear the dirty flag now since we cannot synchronize after this point.
721  //
722 
723  ClearFlag( Packet->Vcb->VcbState, VCB_STATE_FLAG_VOLUME_DIRTY );
724 
726 
727 #ifdef _MSC_VER
728 #pragma prefast( suppress:28159, "prefast indicates this is an obsolete API, but it is ok for fastfat to keep using it" )
729 #endif
731  }
732 
733  return;
734 }
#define VCB_STATE_FLAG_VOLUME_DIRTY
Definition: fatstruc.h:560
VOID NTAPI ExQueueWorkItem(IN PWORK_QUEUE_ITEM WorkItem, IN WORK_QUEUE_TYPE QueueType)
Definition: work.c:717
BOOLEAN NTAPI KeSetTimer(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN PKDPC Dpc OPTIONAL)
Definition: timerobj.c:281
_In_ NDIS_HANDLE _In_ PNDIS_PACKET Packet
Definition: ndis.h:1548
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
BOOLEAN NTAPI CcIsThereDirtyData(IN PVPB Vpb)
Definition: logsup.c:55
Definition: cdstruc.h:504
long LONG
Definition: pedump.c:60
smooth NULL
Definition: ftsmooth.c:416
_In_opt_ PVOID _In_opt_ PVOID SystemArgument1
Definition: ketypes.h:675
_In_ LARGE_INTEGER _In_opt_ PKDPC Dpc
Definition: kefuncs.h:511
#define ExInitializeWorkItem(Item, Routine, Context)
Definition: exfuncs.h:265
VOID NTAPI FatDeferredCleanVolume(_In_ PVOID Parameter)
Definition: verfysup.c:499
#define Vcb
Definition: cdprocs.h:1415
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
struct _VCB * PVCB
Definition: fatstruc.h:556
ClearFlag(Dirent->Flags, DIRENT_FLAG_NOT_PERSISTENT)
_In_opt_ PVOID _In_opt_ PVOID _In_opt_ PVOID SystemArgument2
Definition: ketypes.h:675
LONGLONG QuadPart
Definition: typedefs.h:114
_In_opt_ PVOID DeferredContext
Definition: ketypes.h:675

◆ FatDeferredCleanVolume()

VOID NTAPI FatDeferredCleanVolume ( _In_ PVOID  Parameter)

Definition at line 499 of file verfysup.c.

521 {
523  PLIST_ENTRY Links;
524  PVCB Vcb;
525  IRP_CONTEXT IrpContext;
526  BOOLEAN VcbExists = FALSE;
527 
528  PAGED_CODE();
529 
530  DebugTrace(+1, Dbg, "FatDeferredCleanVolume\n", 0);
531 
533 
534  Vcb = Packet->Vcb;
535 
536  //
537  // Make us appear as a top level FSP request so that we will
538  // receive any errors from the operation.
539  //
540 
542 
543  //
544  // Dummy up and Irp Context so we can call our worker routines
545  //
546 
547  RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT));
548 
549  SetFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
550 
551  //
552  // Acquire shared access to the global lock and make sure this volume
553  // still exists.
554  //
555 
556 #ifdef _MSC_VER
557 #pragma prefast( push )
558 #pragma prefast( disable: 28193, "this will always wait" )
559 #endif
560  FatAcquireSharedGlobal( &IrpContext );
561 #ifdef _MSC_VER
562 #pragma prefast( pop )
563 #endif
564 
565  for (Links = FatData.VcbQueue.Flink;
566  Links != &FatData.VcbQueue;
567  Links = Links->Flink) {
568 
569  PVCB ExistingVcb;
570 
571  ExistingVcb = CONTAINING_RECORD(Links, VCB, VcbLinks);
572 
573  if ( Vcb == ExistingVcb ) {
574 
575  VcbExists = TRUE;
576  break;
577  }
578  }
579 
580  //
581  // If the vcb is good then mark it clean. Ignore any problems.
582  //
583 
584  if ( VcbExists &&
585  (Vcb->VcbCondition == VcbGood) &&
586  !FlagOn(Vcb->VcbState, VCB_STATE_FLAG_SHUTDOWN) ) {
587 
588  _SEH2_TRY {
589 
590  if (!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY)) {
591 
592  FatMarkVolume( &IrpContext, Vcb, VolumeClean );
593  }
594 
595  //
596  // Check for a pathological race condition, and fix it.
597  //
598 
599  if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_VOLUME_DIRTY)) {
600 
601  FatMarkVolume( &IrpContext, Vcb, VolumeDirty );
602 
603  } else {
604 
605  //
606  // Unlock the volume if it is removable.
607  //
608 
609  if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_REMOVABLE_MEDIA) &&
611 
612  FatToggleMediaEjectDisable( &IrpContext, Vcb, FALSE );
613  }
614  }
615 
618 
619  NOTHING;
620  } _SEH2_END;
621  }
622 
623  //
624  // Release the global resource, unpin and repinned Bcbs and return.
625  //
626 
627  FatReleaseGlobal( &IrpContext );
628 
629  _SEH2_TRY {
630 
631  FatUnpinRepinnedBcbs( &IrpContext );
632 
635 
636  NOTHING;
637  } _SEH2_END;
638 
640 
641  //
642  // and finally free the packet.
643  //
644 
645  ExFreePool( Packet );
646 
647  return;
648 }
BOOLEAN NTAPI FsRtlIsNtstatusExpected(IN NTSTATUS NtStatus)
Definition: filter.c:61
#define VCB_STATE_FLAG_VOLUME_DIRTY
Definition: fatstruc.h:560
#define FatReleaseGlobal(IRPCONTEXT)
Definition: fatprocs.h:1636
#define IRP_CONTEXT_FLAG_WAIT
Definition: cdstruc.h:1221
#define VCB_STATE_FLAG_MOUNTED_DIRTY
Definition: fatstruc.h:561
_In_ NDIS_HANDLE _In_ PNDIS_PACKET Packet
Definition: ndis.h:1548
#define TRUE
Definition: types.h:120
VOID FatUnpinRepinnedBcbs(IN PIRP_CONTEXT IrpContext)
Definition: cachesup.c:1407
#define DebugTrace(INDENT, LEVEL, X, Y)
Definition: fatdata.h:313
Definition: cdstruc.h:504
_In_ PVOID Parameter
Definition: ldrtypes.h:241
#define Dbg
Definition: verfysup.c:29
_SEH2_TRY
Definition: create.c:4226
#define EXCEPTION_CONTINUE_SEARCH
Definition: excpt.h:86
#define FALSE
Definition: types.h:117
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
#define VCB_STATE_FLAG_REMOVABLE_MEDIA
Definition: fatstruc.h:559
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _CLEAN_AND_DIRTY_VOLUME_PACKET * PCLEAN_AND_DIRTY_VOLUME_PACKET
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
NTSTATUS FatToggleMediaEjectDisable(IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN BOOLEAN PreventRemoval)
Definition: deviosup.c:3495
FAT_DATA FatData
Definition: fatdata.c:56
#define FatAcquireSharedGlobal(IRPCONTEXT)
Definition: fatprocs.h:1391
#define VCB_STATE_FLAG_BOOT_OR_PAGING_FILE
Definition: fatstruc.h:566
#define Vcb
Definition: cdprocs.h:1415
#define FSRTL_FSP_TOP_LEVEL_IRP
Definition: fsrtltypes.h:59
VOID NTAPI IoSetTopLevelIrp(IN PIRP Irp)
Definition: irp.c:2000
#define NOTHING
Definition: env_spec_w32.h:461
Definition: typedefs.h:119
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
LIST_ENTRY VcbQueue
Definition: fatstruc.h:48
#define VCB_STATE_FLAG_SHUTDOWN
Definition: fatstruc.h:562
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
_SEH2_END
Definition: create.c:4400
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define PAGED_CODE()

Referenced by FatCleanVolumeDpc().

◆ FatFspMarkVolumeDirtyWithRecover()

VOID NTAPI FatFspMarkVolumeDirtyWithRecover ( PVOID  Parameter)

Definition at line 1098 of file verfysup.c.

1123 {
1125  PVCB Vcb;
1126  IRP_CONTEXT IrpContext;
1127  PIRP Irp;
1128 
1129  DebugTrace(+1, Dbg, "FatFspMarkVolumeDirtyWithRecover\n", 0);
1130 
1132 
1133  Vcb = Packet->Vcb;
1134  Irp = Packet->Irp;
1135 
1136  //
1137  // Dummy up the IrpContext so we can call our worker routines
1138  //
1139 
1140  RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT));
1141 
1142  SetFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
1143  IrpContext.OriginatingIrp = Irp;
1144 
1145  //
1146  // Make us appear as a top level FSP request so that we will
1147  // receive any errors from the operation.
1148  //
1149 
1151 
1152  //
1153  // Try to write out the dirty bit. If something goes wrong, we
1154  // tried.
1155  //
1156 
1157  _SEH2_TRY {
1158 
1160 
1161  FatMarkVolume( &IrpContext, Vcb, VolumeDirtyWithSurfaceTest );
1162 
1164 
1165  NOTHING;
1166  } _SEH2_END;
1167 
1169 
1170  //
1171  // Now complete the originating Irp or set the synchronous event.
1172  //
1173 
1174  if (Packet->Event) {
1175  KeSetEvent( Packet->Event, 0, FALSE );
1176  } else {
1178  }
1179 
1180  DebugTrace(-1, Dbg, "FatFspMarkVolumeDirtyWithRecover -> VOID\n", 0);
1181 }
#define IRP_CONTEXT_FLAG_WAIT
Definition: cdstruc.h:1221
#define VCB_STATE_FLAG_MOUNTED_DIRTY
Definition: fatstruc.h:561
_In_ NDIS_HANDLE _In_ PNDIS_PACKET Packet
Definition: ndis.h:1548
_In_ PIRP Irp
Definition: csq.h:116
#define DebugTrace(INDENT, LEVEL, X, Y)
Definition: fatdata.h:313
Definition: cdstruc.h:504
_In_ PVOID Parameter
Definition: ldrtypes.h:241
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
#define Dbg
Definition: verfysup.c:29
_SEH2_TRY
Definition: create.c:4226
#define IO_DISK_INCREMENT
Definition: iotypes.h:572
#define FALSE
Definition: types.h:117
#define _SEH2_GetExceptionInformation()
Definition: pseh2_64.h:11
smooth NULL
Definition: ftsmooth.c:416
#define IoCompleteRequest
Definition: irp.c:1240
struct _CLEAN_AND_DIRTY_VOLUME_PACKET * PCLEAN_AND_DIRTY_VOLUME_PACKET
#define Vcb
Definition: cdprocs.h:1415
#define FSRTL_FSP_TOP_LEVEL_IRP
Definition: fsrtltypes.h:59
VOID NTAPI IoSetTopLevelIrp(IN PIRP Irp)
Definition: irp.c:2000
#define NOTHING
Definition: env_spec_w32.h:461
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
_SEH2_END
Definition: create.c:4400
ULONG FatExceptionFilter(IN PIRP_CONTEXT IrpContext, IN PEXCEPTION_POINTERS ExceptionPointer)
Definition: fatdata.c:204
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6

◆ FatMarkDevForVerifyIfVcbMounted()

BOOLEAN FatMarkDevForVerifyIfVcbMounted ( IN PVCB  Vcb)

Definition at line 213 of file verfysup.c.

234 {
235  BOOLEAN Marked = FALSE;
236  KIRQL SavedIrql;
237 
238  IoAcquireVpbSpinLock( &SavedIrql );
239 
240 #ifdef _MSC_VER
241 #pragma prefast( push )
242 #pragma prefast( disable: 28175, "touching Vpb is ok for a filesystem" )
243 #endif
244 
245  if (Vcb->Vpb->RealDevice->Vpb == Vcb->Vpb) {
246 
247  SetFlag( Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);
248  Marked = TRUE;
249  }
250  else {
251 
252  //
253  // Flag this to avoid the VPB spinlock in future passes.
254  //
255 
257  }
258 
259 #ifdef _MSC_VER
260 #pragma prefast( pop )
261 #endif
262 
263  IoReleaseVpbSpinLock( SavedIrql );
264 
265  return Marked;
266 }
#define TRUE
Definition: types.h:120
#define DO_VERIFY_VOLUME
Definition: env_spec_w32.h:393
VOID NTAPI IoAcquireVpbSpinLock(OUT PKIRQL Irql)
Definition: volume.c:1209
#define Marked(f)
Definition: render.c:146
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define FALSE
Definition: types.h:117
unsigned char BOOLEAN
#define Vcb
Definition: cdprocs.h:1415
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
#define VCB_STATE_VPB_NOT_ON_DEVICE
Definition: cdstruc.h:720
VOID NTAPI IoReleaseVpbSpinLock(IN KIRQL Irql)
Definition: volume.c:1220

Referenced by FatQuickVerifyVcb().

◆ FatMarkVolumeCompletionRoutine()

NTSTATUS NTAPI FatMarkVolumeCompletionRoutine ( _In_ PDEVICE_OBJECT  DeviceObject,
_In_ PIRP  Irp,
_In_reads_opt_(_Inexpressible_("varies")) PVOID  Contxt 
)

Definition at line 2013 of file verfysup.c.

2019 {
2020  //
2021  // Set the event so that our call will wake up.
2022  //
2023 
2024  KeSetEvent( (PKEVENT)Contxt, 0, FALSE );
2025 
2028 
2030 }
#define STATUS_MORE_PROCESSING_REQUIRED
Definition: shellext.h:68
_In_ PIRP Irp
Definition: csq.h:116
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
#define FALSE
Definition: types.h:117
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1569

◆ FatMatchFileSize()

BOOLEAN FatMatchFileSize ( __in PIRP_CONTEXT  IrpContext,
__in PDIRENT  Dirent,
__in PFCB  Fcb 
)

Definition at line 1495 of file verfysup.c.

1500 {
1501 
1502  UNREFERENCED_PARAMETER(IrpContext);
1503 
1504  if (NodeType(Fcb) != FAT_NTC_FCB) {
1505  return TRUE;
1506  }
1507 
1508 
1509  if (Fcb->Header.FileSize.LowPart != Dirent->FileSize) {
1510  return FALSE;
1511  }
1512 
1513 
1514  return TRUE;
1515 }
FSRTL_ADVANCED_FCB_HEADER Header
Definition: cdstruc.h:931
#define TRUE
Definition: types.h:120
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
#define FALSE
Definition: types.h:117
NodeType
Definition: Node.h:5
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT _Inout_ PDIRENT Dirent
Definition: cdprocs.h:424
_In_ PFCB Fcb
Definition: cdprocs.h:159
#define FAT_NTC_FCB
Definition: nodetype.h:29

◆ FatQuickVerifyVcb()

VOID FatQuickVerifyVcb ( IN PIRP_CONTEXT  IrpContext,
IN PVCB  Vcb 
)

Definition at line 1662 of file verfysup.c.

1685 {
1686  PAGED_CODE();
1687 
1688  //
1689  // If the real device needs to be verified we'll set the
1690  // DeviceToVerify to be our real device and raise VerifyRequired.
1691  //
1692 
1693  if (FlagOn(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME)) {
1694 
1695  DebugTrace(0, Dbg, "The Vcb needs to be verified\n", 0);
1696 
1697  IoSetHardErrorOrVerifyDevice( IrpContext->OriginatingIrp,
1698  Vcb->Vpb->RealDevice );
1699 
1700  FatRaiseStatus( IrpContext, STATUS_VERIFY_REQUIRED );
1701  }
1702 
1703  //
1704  // Based on the condition of the Vcb we'll either return to our
1705  // caller or raise an error condition
1706  //
1707 
1708  switch (Vcb->VcbCondition) {
1709 
1710  case VcbGood:
1711 
1712  DebugTrace(0, Dbg, "The Vcb is good\n", 0);
1713 
1714  //
1715  // Do a check here of an operation that would try to modify a
1716  // write protected media.
1717  //
1718 
1719  if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED) &&
1720  ((IrpContext->MajorFunction == IRP_MJ_WRITE) ||
1721  (IrpContext->MajorFunction == IRP_MJ_SET_INFORMATION) ||
1722  (IrpContext->MajorFunction == IRP_MJ_SET_EA) ||
1723  (IrpContext->MajorFunction == IRP_MJ_FLUSH_BUFFERS) ||
1724  (IrpContext->MajorFunction == IRP_MJ_SET_VOLUME_INFORMATION) ||
1725  (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL &&
1726  IrpContext->MinorFunction == IRP_MN_USER_FS_REQUEST &&
1727  IoGetCurrentIrpStackLocation(IrpContext->OriginatingIrp)->Parameters.FileSystemControl.FsControlCode ==
1729 
1730  //
1731  // Set the real device for the pop-up info, and set the verify
1732  // bit in the device object, so that we will force a verify
1733  // in case the user put the correct media back in.
1734  //
1735 
1736 
1737  IoSetHardErrorOrVerifyDevice( IrpContext->OriginatingIrp,
1738  Vcb->Vpb->RealDevice );
1739 
1741 
1743  }
1744 
1745  break;
1746 
1747  case VcbNotMounted:
1748 
1749  DebugTrace(0, Dbg, "The Vcb is not mounted\n", 0);
1750 
1751  //
1752  // Set the real device for the pop-up info, and set the verify
1753  // bit in the device object, so that we will force a verify
1754  // in case the user put the correct media back in.
1755  //
1756 
1757  IoSetHardErrorOrVerifyDevice( IrpContext->OriginatingIrp,
1758  Vcb->Vpb->RealDevice );
1759 
1760  FatRaiseStatus( IrpContext, STATUS_WRONG_VOLUME );
1761 
1762  break;
1763 
1764  case VcbBad:
1765 
1766  DebugTrace(0, Dbg, "The Vcb is bad\n", 0);
1767 
1768  if (FlagOn( Vcb->VcbState, VCB_STATE_FLAG_VOLUME_DISMOUNTED )) {
1769 
1771 
1772  } else {
1773 
1774  FatRaiseStatus( IrpContext, STATUS_FILE_INVALID );
1775  }
1776  break;
1777 
1778  default:
1779 
1780  DebugDump("Invalid VcbCondition\n", 0, Vcb);
1781 #ifdef _MSC_VER
1782 #pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
1783 #endif
1784  FatBugCheck( Vcb->VcbCondition, 0, 0 );
1785  }
1786 }
#define IRP_MJ_FLUSH_BUFFERS
#define DebugTrace(INDENT, LEVEL, X, Y)
Definition: fatdata.h:313
#define DO_VERIFY_VOLUME
Definition: env_spec_w32.h:393
#define IRP_MJ_SET_VOLUME_INFORMATION
#define VCB_STATE_FLAG_WRITE_PROTECTED
Definition: fatstruc.h:569
#define STATUS_FILE_INVALID
Definition: ntstatus.h:388
#define STATUS_WRONG_VOLUME
Definition: udferr_usr.h:140
#define VCB_STATE_FLAG_VOLUME_DISMOUNTED
Definition: fatstruc.h:571
#define FatRaiseStatus(IRPCONTEXT, STATUS)
Definition: fatprocs.h:2974
#define STATUS_VERIFY_REQUIRED
Definition: udferr_usr.h:130
#define FSCTL_MARK_VOLUME_DIRTY
Definition: nt_native.h:838
#define Dbg
Definition: verfysup.c:29
#define IRP_MJ_SET_EA
#define FatBugCheck(A, B, C)
Definition: nodetype.h:104
#define STATUS_MEDIA_WRITE_PROTECTED
Definition: udferr_usr.h:161
#define IRP_MN_USER_FS_REQUEST
Definition: iotypes.h:4054
#define IRP_MJ_FILE_SYSTEM_CONTROL
BOOLEAN FatMarkDevForVerifyIfVcbMounted(IN PVCB Vcb)
Definition: verfysup.c:213
#define Vcb
Definition: cdprocs.h:1415
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2789
#define STATUS_VOLUME_DISMOUNTED
Definition: ntstatus.h:747
#define IRP_MJ_SET_INFORMATION
Definition: rdpdr.c:49
VOID NTAPI IoSetHardErrorOrVerifyDevice(IN PIRP Irp, IN PDEVICE_OBJECT DeviceObject)
Definition: util.c:316
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2779
#define PAGED_CODE()
#define DebugDump(STR, LEVEL, PTR)
Definition: fatdata.h:314

Referenced by _Requires_lock_held_(), and FatVerifyVcb().

◆ FatResetFcb()

VOID FatResetFcb ( IN PIRP_CONTEXT  IrpContext,
IN PFCB  Fcb 
)

Definition at line 1396 of file verfysup.c.

1423 {
1424  LOGICAL IsRealPagingFile;
1425 
1426  PAGED_CODE();
1427  UNREFERENCED_PARAMETER( IrpContext );
1428 
1429  //
1430  // Don't do the two following operations for the Root Dcb
1431  // of a non FAT32 volume or paging files. Paging files!?
1432  // Yes, if someone diddles a volume we try to reverify all
1433  // of the Fcbs just in case; however, there is no safe way
1434  // to chuck and retrieve the mapping pair information for
1435  // a real paging file. Lose it and die.
1436  //
1437  // An exception is made for ReadyBoost cache files, which
1438  // are created as paging files on removable devices and
1439  // require validation after a power transition.
1440  //
1441 
1444 
1445  IsRealPagingFile = TRUE;
1446 
1447  } else {
1448 
1449  IsRealPagingFile = FALSE;
1450  }
1451 
1452  if ( (NodeType(Fcb) != FAT_NTC_ROOT_DCB ||
1453  FatIsFat32( Fcb->Vcb )) &&
1454  !IsRealPagingFile ) {
1455 
1456  //
1457  // Reset the mcb mapping.
1458  //
1459 
1460  FsRtlRemoveLargeMcbEntry( &Fcb->Mcb, 0, 0xFFFFFFFF );
1461 
1462  //
1463  // Reset the allocation size to 0 or unknown
1464  //
1465 
1466  if ( Fcb->FirstClusterOfFile == 0 ) {
1467 
1468  Fcb->Header.AllocationSize.QuadPart = 0;
1469 
1470  } else {
1471 
1472  Fcb->Header.AllocationSize.QuadPart = FCB_LOOKUP_ALLOCATIONSIZE_HINT;
1473  }
1474  }
1475 
1476  //
1477  // If this is a directory, reset the hints.
1478  //
1479 
1480  if ( (NodeType(Fcb) == FAT_NTC_DCB) ||
1481  (NodeType(Fcb) == FAT_NTC_ROOT_DCB) ) {
1482 
1483  //
1484  // Force a rescan of the directory
1485  //
1486 
1487  Fcb->Specific.Dcb.UnusedDirentVbo = 0xffffffff;
1488  Fcb->Specific.Dcb.DeletedDirentHint = 0xffffffff;
1489  }
1490 }
struct _FCB::@715::@717 Dcb
#define FCB_LOOKUP_ALLOCATIONSIZE_HINT
Definition: fatstruc.h:1240
FSRTL_ADVANCED_FCB_HEADER Header
Definition: cdstruc.h:931
#define TRUE
Definition: types.h:120
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
VOID NTAPI FsRtlRemoveLargeMcbEntry(IN PLARGE_MCB Mcb, IN LONGLONG Vbn, IN LONGLONG SectorCount)
Definition: largemcb.c:862
ULONG VcbState
Definition: cdstruc.h:546
#define FALSE
Definition: types.h:117
#define FCB_STATE_PAGING_FILE
Definition: fatstruc.h:1194
#define VCB_STATE_FLAG_REMOVABLE_MEDIA
Definition: fatstruc.h:559
union _FCB::@715 Specific
NodeType
Definition: Node.h:5
CD_MCB Mcb
Definition: cdstruc.h:1022
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
#define FatIsFat32(VCB)
Definition: fatprocs.h:1446
#define FAT_NTC_ROOT_DCB
Definition: nodetype.h:31
#define FAT_NTC_DCB
Definition: nodetype.h:30
ULONG FirstClusterOfFile
Definition: fatstruc.h:817
PVCB Vcb
Definition: cdstruc.h:939
_In_ PFCB Fcb
Definition: cdprocs.h:159
ULONG FcbState
Definition: cdstruc.h:977
#define PAGED_CODE()

◆ FatVerifyOperationIsLegal()

VOID FatVerifyOperationIsLegal ( IN PIRP_CONTEXT  IrpContext)

Definition at line 1304 of file verfysup.c.

1326 {
1327  PIRP Irp;
1329 
1330  PAGED_CODE();
1331 
1332  Irp = IrpContext->OriginatingIrp;
1333 
1334  //
1335  // If the Irp is not present, then we got here via close.
1336  //
1337  //
1338 
1339  if ( Irp == NULL ) {
1340 
1341  return;
1342  }
1343 
1345 
1346  //
1347  // If there is not a file object, we cannot continue.
1348  //
1349 
1350  if ( FileObject == NULL ) {
1351 
1352  return;
1353  }
1354 
1355  //
1356  // If the file object has already been cleaned up, and
1357  //
1358  // A) This request is a paging io read or write, or
1359  // B) This request is a close operation, or
1360  // C) This request is a set or query info call (for Lou)
1361  // D) This is an MDL complete
1362  //
1363  // let it pass, otherwise return STATUS_FILE_CLOSED.
1364  //
1365 
1366  if ( FlagOn(FileObject->Flags, FO_CLEANUP_COMPLETE) ) {
1367 
1369 
1370  if ( (FlagOn(Irp->Flags, IRP_PAGING_IO)) ||
1371  (IrpSp->MajorFunction == IRP_MJ_CLOSE ) ||
1374  ( ( (IrpSp->MajorFunction == IRP_MJ_READ) ||
1375  (IrpSp->MajorFunction == IRP_MJ_WRITE) ) &&
1377 
1378  NOTHING;
1379 
1380  } else {
1381 
1382  FatRaiseStatus( IrpContext, STATUS_FILE_CLOSED );
1383  }
1384  }
1385 
1386  return;
1387 }
_In_ PIRP Irp
Definition: csq.h:116
#define FatRaiseStatus(IRPCONTEXT, STATUS)
Definition: fatprocs.h:2974
#define IRP_MN_COMPLETE
Definition: iotypes.h:4071
smooth NULL
Definition: ftsmooth.c:416
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:588
* PFILE_OBJECT
Definition: iotypes.h:1962
#define IRP_MJ_CLOSE
Definition: rdpdr.c:45
#define NOTHING
Definition: env_spec_w32.h:461
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2789
PFILE_OBJECT FileObject
Definition: iotypes.h:2820
#define FO_CLEANUP_COMPLETE
Definition: iotypes.h:1754
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4137
#define IRP_PAGING_IO
#define IRP_MJ_READ
Definition: rdpdr.c:46
#define IRP_MJ_SET_INFORMATION
Definition: rdpdr.c:49
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
#define IRP_MJ_QUERY_INFORMATION
Definition: rdpdr.c:48
#define PAGED_CODE()
#define STATUS_FILE_CLOSED
Definition: ntstatus.h:532

Referenced by _Requires_lock_held_().

◆ FatVerifyVcb()

VOID FatVerifyVcb ( IN PIRP_CONTEXT  IrpContext,
IN PVCB  Vcb 
)

Definition at line 270 of file verfysup.c.

292 {
293  BOOLEAN DevMarkedForVerify;
294 
295  PAGED_CODE();
296 
297  DebugTrace(+1, Dbg, "FatVerifyVcb, Vcb = %p\n", Vcb );
298 
299  //
300  // If the verify volume flag in the device object is set
301  // this means the media has potentially changed.
302  //
303  // Note that we only force this ping for create operations.
304  // For others we take a sporting chance. If in the end we
305  // have to physically access the disk, the right thing will happen.
306  //
307 
308  DevMarkedForVerify = BooleanFlagOn(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);
309 
310  //
311  // We ALWAYS force CREATE requests on unmounted volumes through the
312  // verify path. These requests could have been in limbo between
313  // IoCheckMountedVpb and us, when a verify/mount took place and caused
314  // a completely different fs/volume to be mounted. In this case the
315  // checks above may not have caught the condition, since we may already
316  // have verified (wrong volume) and decided that we have nothing to do.
317  // We want the requests to be re routed to the currently mounted volume,
318  // since they were directed at the 'drive', not our volume. So we take
319  // the verify path for synchronisation, and the request will eventually
320  // be bounced back to IO with STATUS_REPARSE by our verify handler.
321  //
322 
323  if (!DevMarkedForVerify &&
324  (IrpContext->MajorFunction == IRP_MJ_CREATE) &&
325  (IrpContext->OriginatingIrp != NULL)) {
326 
327  PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( IrpContext->OriginatingIrp);
328 
329  if ((IrpSp->FileObject->RelatedFileObject == NULL) &&
330  (Vcb->VcbCondition == VcbNotMounted)) {
331 
332  DevMarkedForVerify = TRUE;
333  }
334  }
335 
336  //
337  // Raise any error condition otherwise.
338  //
339 
340  if (DevMarkedForVerify) {
341 
342  DebugTrace(0, Dbg, "The Vcb needs to be verified\n", 0);
343 
344  IoSetHardErrorOrVerifyDevice( IrpContext->OriginatingIrp,
345  Vcb->Vpb->RealDevice );
346 
348  }
349 
350  //
351  // Check the operation is legal for current Vcb state.
352  //
353 
354  FatQuickVerifyVcb( IrpContext, Vcb );
355 
356  DebugTrace(-1, Dbg, "FatVerifyVcb -> VOID\n", 0);
357 }
#define FatNormalizeAndRaiseStatus(IRPCONTEXT, STATUS)
Definition: fatprocs.h:2992
#define IRP_MJ_CREATE
Definition: rdpdr.c:44
#define TRUE
Definition: types.h:120
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
#define DebugTrace(INDENT, LEVEL, X, Y)
Definition: fatdata.h:313
#define DO_VERIFY_VOLUME
Definition: env_spec_w32.h:393
#define STATUS_VERIFY_REQUIRED
Definition: udferr_usr.h:130
#define Dbg
Definition: verfysup.c:29
VOID FatQuickVerifyVcb(IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
Definition: verfysup.c:1662
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
#define Vcb
Definition: cdprocs.h:1415
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2789
PFILE_OBJECT FileObject
Definition: iotypes.h:2820
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4137
VOID NTAPI IoSetHardErrorOrVerifyDevice(IN PIRP Irp, IN PDEVICE_OBJECT DeviceObject)
Definition: util.c:316
#define PAGED_CODE()

Referenced by FatFlushFat(), FatIsVolumeDirty(), and FatIsVolumeMounted().