ReactOS  0.4.13-dev-92-gf251225
misc.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS kernel
4  * FILE: drivers/fs/vfat/misc.c
5  * PURPOSE: VFAT Filesystem
6  * PROGRAMMER:
7  *
8  */
9 
10 /* INCLUDES *****************************************************************/
11 
12 #include "vfat.h"
13 
14 #define NDEBUG
15 #include <debug.h>
16 
17 /* GLOBALS ******************************************************************/
18 
19 const char* MajorFunctionNames[] =
20 {
21  "IRP_MJ_CREATE",
22  "IRP_MJ_CREATE_NAMED_PIPE",
23  "IRP_MJ_CLOSE",
24  "IRP_MJ_READ",
25  "IRP_MJ_WRITE",
26  "IRP_MJ_QUERY_INFORMATION",
27  "IRP_MJ_SET_INFORMATION",
28  "IRP_MJ_QUERY_EA",
29  "IRP_MJ_SET_EA",
30  "IRP_MJ_FLUSH_BUFFERS",
31  "IRP_MJ_QUERY_VOLUME_INFORMATION",
32  "IRP_MJ_SET_VOLUME_INFORMATION",
33  "IRP_MJ_DIRECTORY_CONTROL",
34  "IRP_MJ_FILE_SYSTEM_CONTROL",
35  "IRP_MJ_DEVICE_CONTROL",
36  "IRP_MJ_INTERNAL_DEVICE_CONTROL",
37  "IRP_MJ_SHUTDOWN",
38  "IRP_MJ_LOCK_CONTROL",
39  "IRP_MJ_CLEANUP",
40  "IRP_MJ_CREATE_MAILSLOT",
41  "IRP_MJ_QUERY_SECURITY",
42  "IRP_MJ_SET_SECURITY",
43  "IRP_MJ_POWER",
44  "IRP_MJ_SYSTEM_CONTROL",
45  "IRP_MJ_DEVICE_CHANGE",
46  "IRP_MJ_QUERY_QUOTA",
47  "IRP_MJ_SET_QUOTA",
48  "IRP_MJ_PNP",
49  "IRP_MJ_MAXIMUM_FUNCTION"
50 };
51 
52 static LONG QueueCount = 0;
53 
57 
58 /* FUNCTIONS ****************************************************************/
59 
60 static
63  IN PVFAT_IRP_CONTEXT IrpContext)
64 {
65  PVFATFCB Fcb;
67 
68  DPRINT("VfatLockControl(IrpContext %p)\n", IrpContext);
69 
70  ASSERT(IrpContext);
71 
72  Fcb = (PVFATFCB)IrpContext->FileObject->FsContext;
73 
74  if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
75  {
77  }
78 
80  {
82  }
83 
84  IrpContext->Flags &= ~IRPCONTEXT_COMPLETE;
86  IrpContext->Irp,
87  NULL);
88  return Status;
89 }
90 
91 static
94  IN PVFAT_IRP_CONTEXT IrpContext)
95 {
96  IoSkipCurrentIrpStackLocation(IrpContext->Irp);
97 
98  IrpContext->Flags &= ~IRPCONTEXT_COMPLETE;
99 
100  return IoCallDriver(IrpContext->DeviceExt->StorageDevice, IrpContext->Irp);
101 }
102 
103 static
104 NTSTATUS
106  IN PVFAT_IRP_CONTEXT IrpContext)
107 {
109  BOOLEAN QueueIrp, CompleteIrp;
110 
111  DPRINT("VfatDispatchRequest (IrpContext %p), is called for %s\n", IrpContext,
112  IrpContext->MajorFunction >= IRP_MJ_MAXIMUM_FUNCTION ? "????" : MajorFunctionNames[IrpContext->MajorFunction]);
113 
114  ASSERT(IrpContext);
115 
117 
118  switch (IrpContext->MajorFunction)
119  {
120  case IRP_MJ_CLOSE:
121  Status = VfatClose(IrpContext);
122  break;
123 
124  case IRP_MJ_CREATE:
125  Status = VfatCreate(IrpContext);
126  break;
127 
128  case IRP_MJ_READ:
129  Status = VfatRead(IrpContext);
130  break;
131 
132  case IRP_MJ_WRITE:
133  Status = VfatWrite (IrpContext);
134  break;
135 
137  Status = VfatFileSystemControl(IrpContext);
138  break;
139 
141  Status = VfatQueryInformation (IrpContext);
142  break;
143 
145  Status = VfatSetInformation (IrpContext);
146  break;
147 
149  Status = VfatDirectoryControl(IrpContext);
150  break;
151 
153  Status = VfatQueryVolumeInformation(IrpContext);
154  break;
155 
157  Status = VfatSetVolumeInformation(IrpContext);
158  break;
159 
160  case IRP_MJ_LOCK_CONTROL:
161  Status = VfatLockControl(IrpContext);
162  break;
163 
165  Status = VfatDeviceControl(IrpContext);
166  break;
167 
168  case IRP_MJ_CLEANUP:
169  Status = VfatCleanup(IrpContext);
170  break;
171 
173  Status = VfatFlush(IrpContext);
174  break;
175 
176  case IRP_MJ_PNP:
177  Status = VfatPnp(IrpContext);
178  break;
179 
180  default:
181  DPRINT1("Unexpected major function %x\n", IrpContext->MajorFunction);
183  }
184 
185  QueueIrp = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_QUEUE);
186  CompleteIrp = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_COMPLETE);
187 
188  ASSERT((!CompleteIrp && !QueueIrp) ||
189  (CompleteIrp && !QueueIrp) ||
190  (!CompleteIrp && QueueIrp));
191 
192  if (CompleteIrp)
193  {
194  IrpContext->Irp->IoStatus.Status = Status;
195  IoCompleteRequest(IrpContext->Irp, IrpContext->PriorityBoost);
196  }
197 
198  if (QueueIrp)
199  {
200  /* Reset our status flags before queueing the IRP */
201  IrpContext->Flags |= IRPCONTEXT_COMPLETE;
202  IrpContext->Flags &= ~IRPCONTEXT_QUEUE;
203  Status = VfatQueueRequest(IrpContext);
204  }
205  else
206  {
207  /* Unless the IRP was queued, always free the IRP context */
208  VfatFreeIrpContext(IrpContext);
209  }
210 
212 
213  return Status;
214 }
215 
216 VOID
217 NTAPI
219  IN PVOID IrpContext,
220  IN PVOID Unused)
221 {
223 }
224 
225 NTSTATUS
226 NTAPI
229  IN PIRP Irp)
230 {
232  PVFAT_IRP_CONTEXT IrpContext;
233 
234  DPRINT("VfatBuildRequest (DeviceObject %p, Irp %p)\n", DeviceObject, Irp);
235 
237  ASSERT(Irp);
238 
239  IrpContext = VfatAllocateIrpContext(DeviceObject, Irp);
240  if (IrpContext == NULL)
241  {
243  Irp->IoStatus.Status = Status;
245  }
246  else
247  {
248  Status = VfatDispatchRequest(IrpContext);
249  }
250  return Status;
251 }
252 
253 static
254 VOID
256  PVFAT_IRP_CONTEXT IrpContext)
257 {
258  ASSERT(IrpContext);
259  ExFreeToNPagedLookasideList(&VfatGlobalData->IrpContextLookasideList, IrpContext);
260 }
261 
262 static
266  PIRP Irp)
267 {
268  PVFAT_IRP_CONTEXT IrpContext;
269  /*PIO_STACK_LOCATION Stack;*/
270  UCHAR MajorFunction;
271 
272  DPRINT("VfatAllocateIrpContext(DeviceObject %p, Irp %p)\n", DeviceObject, Irp);
273 
275  ASSERT(Irp);
276 
277  IrpContext = ExAllocateFromNPagedLookasideList(&VfatGlobalData->IrpContextLookasideList);
278  if (IrpContext)
279  {
280  RtlZeroMemory(IrpContext, sizeof(VFAT_IRP_CONTEXT));
281  IrpContext->Irp = Irp;
282  IrpContext->DeviceObject = DeviceObject;
283  IrpContext->DeviceExt = DeviceObject->DeviceExtension;
284  IrpContext->Stack = IoGetCurrentIrpStackLocation(Irp);
285  ASSERT(IrpContext->Stack);
286  MajorFunction = IrpContext->MajorFunction = IrpContext->Stack->MajorFunction;
287  IrpContext->MinorFunction = IrpContext->Stack->MinorFunction;
288  IrpContext->FileObject = IrpContext->Stack->FileObject;
289  IrpContext->Flags = IRPCONTEXT_COMPLETE;
290 
291  /* Easy cases that can wait */
292  if (MajorFunction == IRP_MJ_CLEANUP ||
293  MajorFunction == IRP_MJ_CREATE ||
294  MajorFunction == IRP_MJ_SHUTDOWN ||
295  MajorFunction == IRP_MJ_CLOSE /* likely to be fixed */)
296  {
297  SetFlag(IrpContext->Flags, IRPCONTEXT_CANWAIT);
298  }
299  /* Cases that can wait if synchronous IRP */
300  else if ((MajorFunction == IRP_MJ_DEVICE_CONTROL ||
301  MajorFunction == IRP_MJ_QUERY_INFORMATION ||
302  MajorFunction == IRP_MJ_SET_INFORMATION ||
303  MajorFunction == IRP_MJ_FLUSH_BUFFERS ||
304  MajorFunction == IRP_MJ_LOCK_CONTROL ||
305  MajorFunction == IRP_MJ_QUERY_VOLUME_INFORMATION ||
306  MajorFunction == IRP_MJ_SET_VOLUME_INFORMATION ||
307  MajorFunction == IRP_MJ_DIRECTORY_CONTROL ||
308  MajorFunction == IRP_MJ_WRITE ||
309  MajorFunction == IRP_MJ_READ) &&
311  {
312  SetFlag(IrpContext->Flags, IRPCONTEXT_CANWAIT);
313  }
314  /* Cases that can wait if synchronous or if no FO */
315  else if ((MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL ||
316  MajorFunction == IRP_MJ_PNP) &&
319  {
320  SetFlag(IrpContext->Flags, IRPCONTEXT_CANWAIT);
321  }
322 
324  IrpContext->RefCount = 0;
325  IrpContext->PriorityBoost = IO_NO_INCREMENT;
326  }
327  return IrpContext;
328 }
329 
330 static WORKER_THREAD_ROUTINE VfatDoRequest;
331 
332 static
333 VOID
334 NTAPI
336  PVOID IrpContext)
337 {
339  DPRINT("VfatDoRequest(IrpContext %p), MajorFunction %x, %d\n",
340  IrpContext, ((PVFAT_IRP_CONTEXT)IrpContext)->MajorFunction, QueueCount);
342 }
343 
344 static
345 NTSTATUS
347  PVFAT_IRP_CONTEXT IrpContext)
348 {
350  DPRINT("VfatQueueRequest(IrpContext %p), %d\n", IrpContext, QueueCount);
351 
352  ASSERT(IrpContext != NULL);
353  ASSERT(IrpContext->Irp != NULL);
354  ASSERT(!(IrpContext->Flags & IRPCONTEXT_QUEUE) &&
355  (IrpContext->Flags & IRPCONTEXT_COMPLETE));
356 
357  IrpContext->Flags |= IRPCONTEXT_CANWAIT;
358  IoMarkIrpPending(IrpContext->Irp);
359  ExInitializeWorkItem(&IrpContext->WorkQueueItem, VfatDoRequest, IrpContext);
361  return STATUS_PENDING;
362 }
363 
364 PVOID
366  IN PIRP Irp,
367  IN BOOLEAN Paging)
368 {
369  ASSERT(Irp);
370 
371  if (Irp->MdlAddress)
372  {
373  return MmGetSystemAddressForMdlSafe(Irp->MdlAddress, (Paging ? HighPagePriority : NormalPagePriority));
374  }
375  else
376  {
377  return Irp->UserBuffer;
378  }
379 }
380 
381 NTSTATUS
383  IN PIRP Irp,
384  IN ULONG Length,
386 {
387  ASSERT(Irp);
388 
389  if (Irp->MdlAddress)
390  {
391  return STATUS_SUCCESS;
392  }
393 
394  IoAllocateMdl(Irp->UserBuffer, Length, FALSE, FALSE, Irp);
395 
396  if (!Irp->MdlAddress)
397  {
399  }
400 
401  _SEH2_TRY
402  {
403  MmProbeAndLockPages(Irp->MdlAddress, Irp->RequestorMode, Operation);
404  }
406  {
407  IoFreeMdl(Irp->MdlAddress);
408  Irp->MdlAddress = NULL;
410  }
411  _SEH2_END;
412 
413  return STATUS_SUCCESS;
414 }
415 
416 BOOLEAN
418  IN PDEVICE_EXTENSION DeviceExt,
419  IN BOOLEAN Force)
420 {
421  KIRQL OldIrql;
422  ULONG UnCleanCount;
423  PVPB Vpb;
424  BOOLEAN Delete;
425 
426  DPRINT1("VfatCheckForDismount(%p, %u)\n", DeviceExt, Force);
427 
428  /* If the VCB is OK (not under uninitialization) and we don't force dismount, do nothing */
429  if (BooleanFlagOn(DeviceExt->Flags, VCB_GOOD) && !Force)
430  {
431  return FALSE;
432  }
433 
434  /*
435  * NOTE: In their *CheckForDismount() function, our 3rd-party FS drivers
436  * as well as MS' fastfat, perform a comparison check of the current VCB's
437  * VPB ReferenceCount with some sort of "dangling"/"residual" open count,
438  * depending on whether or not we are in IRP_MJ_CREATE.
439  * It seems to be related to the fact that the volume root directory as
440  * well as auxiliary data stream(s) are still opened, and only these are
441  * allowed to be opened at that moment. After analysis it appears that for
442  * the ReactOS' fastfat, this number is equal to "3".
443  */
444  UnCleanCount = 3;
445 
446  /* Lock VPB */
448 
449  /* Reference it and check if a create is being done */
450  Vpb = DeviceExt->IoVPB;
451  DPRINT("Vpb->ReferenceCount = %d\n", Vpb->ReferenceCount);
452  if (Vpb->ReferenceCount != UnCleanCount || DeviceExt->OpenHandleCount != 0)
453  {
454  /* If we force-unmount, copy the VPB to our local own to prepare later dismount */
455  if (Force && Vpb->RealDevice->Vpb == Vpb && DeviceExt->SpareVPB != NULL)
456  {
457  RtlZeroMemory(DeviceExt->SpareVPB, sizeof(VPB));
458  DeviceExt->SpareVPB->Type = IO_TYPE_VPB;
459  DeviceExt->SpareVPB->Size = sizeof(VPB);
460  DeviceExt->SpareVPB->RealDevice = DeviceExt->IoVPB->RealDevice;
461  DeviceExt->SpareVPB->DeviceObject = NULL;
462  DeviceExt->SpareVPB->Flags = DeviceExt->IoVPB->Flags & VPB_REMOVE_PENDING;
463  DeviceExt->IoVPB->RealDevice->Vpb = DeviceExt->SpareVPB;
464  DeviceExt->SpareVPB = NULL;
465  DeviceExt->IoVPB->Flags |= VPB_PERSISTENT;
466 
467  /* We are uninitializing, the VCB cannot be used anymore */
468  ClearFlag(DeviceExt->Flags, VCB_GOOD);
469  }
470 
471  /* Don't do anything for now */
472  Delete = FALSE;
473  }
474  else
475  {
476  /* Otherwise, delete the volume */
477  Delete = TRUE;
478 
479  /* Swap the VPB with our local own */
480  if (Vpb->RealDevice->Vpb == Vpb && DeviceExt->SpareVPB != NULL)
481  {
482  RtlZeroMemory(DeviceExt->SpareVPB, sizeof(VPB));
483  DeviceExt->SpareVPB->Type = IO_TYPE_VPB;
484  DeviceExt->SpareVPB->Size = sizeof(VPB);
485  DeviceExt->SpareVPB->RealDevice = DeviceExt->IoVPB->RealDevice;
486  DeviceExt->SpareVPB->DeviceObject = NULL;
487  DeviceExt->SpareVPB->Flags = DeviceExt->IoVPB->Flags & VPB_REMOVE_PENDING;
488  DeviceExt->IoVPB->RealDevice->Vpb = DeviceExt->SpareVPB;
489  DeviceExt->SpareVPB = NULL;
490  DeviceExt->IoVPB->Flags |= VPB_PERSISTENT;
491 
492  /* We are uninitializing, the VCB cannot be used anymore */
493  ClearFlag(DeviceExt->Flags, VCB_GOOD);
494  }
495 
496  /*
497  * We defer setting the VPB's DeviceObject to NULL for later because
498  * we want to handle the closing of the internal opened meta-files.
499  */
500 
501  /* Clear the mounted and locked flags in the VPB */
502  ClearFlag(Vpb->Flags, VPB_MOUNTED | VPB_LOCKED);
503  }
504 
505  /* Release lock and return status */
507 
508  /* If we were to delete, delete volume */
509  if (Delete)
510  {
511  LARGE_INTEGER Zero = {{0,0}};
512  PVFATFCB Fcb;
513 
514  /* We are uninitializing, the VCB cannot be used anymore */
515  ClearFlag(DeviceExt->Flags, VCB_GOOD);
516 
517  /* Invalidate and close the internal opened meta-files */
518  if (DeviceExt->RootFcb)
519  {
520  Fcb = DeviceExt->RootFcb;
522  &Zero,
523  NULL);
525  DeviceExt->RootFcb = NULL;
527  }
528  if (DeviceExt->VolumeFcb)
529  {
530  Fcb = DeviceExt->VolumeFcb;
531 #ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
533  &Zero,
534  NULL);
536 #endif
537  DeviceExt->VolumeFcb = NULL;
539  }
540  if (DeviceExt->FATFileObject)
541  {
542  Fcb = DeviceExt->FATFileObject->FsContext;
543  CcUninitializeCacheMap(DeviceExt->FATFileObject,
544  &Zero,
545  NULL);
546  DeviceExt->FATFileObject->FsContext = NULL;
547  ObDereferenceObject(DeviceExt->FATFileObject);
548  DeviceExt->FATFileObject = NULL;
550  }
551 
552  /*
553  * Now that the closing of the internal opened meta-files has been
554  * handled, we can now set the VPB's DeviceObject to NULL.
555  */
556  Vpb->DeviceObject = NULL;
557 
558  /* If we have a local VPB, we'll have to delete it
559  * but we won't dismount us - something went bad before
560  */
561  if (DeviceExt->SpareVPB)
562  {
563  ExFreePool(DeviceExt->SpareVPB);
564  }
565  /* Otherwise, delete any of the available VPB if its reference count is zero */
566  else if (DeviceExt->IoVPB->ReferenceCount == 0)
567  {
568  ExFreePool(DeviceExt->IoVPB);
569  }
570 
571  /* Remove the volume from the list */
573  RemoveEntryList(&DeviceExt->VolumeListEntry);
575 
576  /* Uninitialize the notify synchronization object */
577  FsRtlNotifyUninitializeSync(&DeviceExt->NotifySync);
578 
579  /* Release resources */
580  ExFreePoolWithTag(DeviceExt->Statistics, TAG_STATS);
581  ExDeleteResourceLite(&DeviceExt->DirResource);
582  ExDeleteResourceLite(&DeviceExt->FatResource);
583 
584  /* Dismount our device if possible */
585  ObfDereferenceObject(DeviceExt->StorageDevice);
586  IoDeleteDevice(DeviceExt->VolumeDevice);
587  }
588 
589  return Delete;
590 }
NTSTATUS VfatCreate(PVFAT_IRP_CONTEXT IrpContext)
Definition: create.c:1083
LONG_PTR FASTCALL ObfDereferenceObject(IN PVOID Object)
Definition: obref.c:320
FILE_LOCK FileLock
Definition: fatstruc.h:1067
_Must_inspect_result_ typedef _In_ PVOID Unused
Definition: iotypes.h:1128
#define IN
Definition: typedefs.h:38
const char * MajorFunctionNames[]
Definition: misc.c:19
#define TRUE
Definition: types.h:120
#define IRP_MJ_CREATE
Definition: rdpdr.c:44
VOID NTAPI ExQueueWorkItem(IN PWORK_QUEUE_ITEM WorkItem, IN WORK_QUEUE_TYPE QueueType)
Definition: work.c:717
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define FsRtlEnterFileSystem
#define IRP_MJ_FLUSH_BUFFERS
#define FsRtlExitFileSystem
Definition: vfat.h:441
#define IRPCONTEXT_COMPLETE
Definition: vfat.h:570
PFILE_OBJECT FileObject
Definition: ntfs.h:504
PDEVICE_EXTENSION DeviceExt
Definition: vfat.h:579
#define IRP_MJ_SHUTDOWN
_In_ PIRP Irp
Definition: csq.h:116
static NTSTATUS VfatDeviceControl(IN PVFAT_IRP_CONTEXT IrpContext)
Definition: misc.c:93
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
static PVFAT_IRP_CONTEXT VfatAllocateIrpContext(PDEVICE_OBJECT, PIRP)
Definition: misc.c:264
NTSTATUS VfatCleanup(PVFAT_IRP_CONTEXT IrpContext)
Definition: cleanup.c:175
NTSTATUS VfatWrite(PVFAT_IRP_CONTEXT IrpContext)
Definition: rw.c:875
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
#define IRP_MJ_MAXIMUM_FUNCTION
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS VfatQueryVolumeInformation(PVFAT_IRP_CONTEXT IrpContext)
Definition: volume.c:432
#define IRP_MJ_SET_VOLUME_INFORMATION
static VOID VfatFreeIrpContext(PVFAT_IRP_CONTEXT)
Definition: misc.c:255
NTSTATUS NTAPI VfatBuildRequest(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: misc.c:227
NTSTATUS NTAPI ExDeleteResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1456
FORCEINLINE BOOLEAN vfatFCBIsDirectory(PVFATFCB FCB)
Definition: vfat.h:631
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
VOID NTAPI IoAcquireVpbSpinLock(OUT PKIRQL Irql)
Definition: volume.c:1201
PVPB Vpb
Definition: cdstruc.h:517
VOID NTAPI ObDereferenceObject(IN PVOID Object)
Definition: obref.c:375
#define VPB_PERSISTENT
Definition: iotypes.h:1765
static WORKER_THREAD_ROUTINE VfatDoRequest
Definition: misc.c:330
BOOLEAN NTAPI IoIsOperationSynchronous(IN PIRP Irp)
Definition: irp.c:1882
NPAGED_LOOKASIDE_LIST IrpContextLookasideList
Definition: vfat.h:413
#define MmGetSystemAddressForMdlSafe(_Mdl, _Priority)
PFILE_OBJECT FileObject
Definition: vfat.h:585
VOID CompleteIrp(IN PIRP Irp, IN NTSTATUS Status, IN ULONG_PTR Information)
Definition: pnp.c:12
_SEH2_TRY
Definition: create.c:4250
ULONG RefCount
Definition: vfat.h:586
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
BOOLEAN NTAPI ExAcquireResourceExclusiveLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:770
UCHAR KIRQL
Definition: env_spec_w32.h:591
static NTSTATUS VfatQueueRequest(PVFAT_IRP_CONTEXT)
Definition: misc.c:346
CCHAR PriorityBoost
Definition: vfat.h:588
NTSTATUS VfatSetInformation(PVFAT_IRP_CONTEXT IrpContext)
Definition: finfo.c:1557
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
long LONG
Definition: pedump.c:60
#define VPB_LOCKED
Definition: iotypes.h:1764
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
KEVENT Event
Definition: vfat.h:587
#define IRPCONTEXT_QUEUE
Definition: vfat.h:571
PVOID DeviceExtension
Definition: env_spec_w32.h:418
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
NTSTATUS VfatQueryInformation(PVFAT_IRP_CONTEXT IrpContext)
Definition: finfo.c:1430
#define IRPCONTEXT_CANWAIT
Definition: vfat.h:569
static NTSTATUS VfatDispatchRequest(IN PVFAT_IRP_CONTEXT IrpContext)
Definition: misc.c:105
#define IoCompleteRequest
Definition: irp.c:1240
void DPRINT(...)
Definition: polytest.cpp:61
PVOID VfatGetUserBuffer(IN PIRP Irp, IN BOOLEAN Paging)
Definition: misc.c:365
#define IRP_MJ_QUERY_VOLUME_INFORMATION
Definition: rdpdr.c:50
#define IRP_MJ_DIRECTORY_CONTROL
Definition: rdpdr.c:51
#define VPB_REMOVE_PENDING
Definition: ntifs_ex.h:428
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
PDEVICE_OBJECT DeviceObject
Definition: vfat.h:406
#define ExInitializeWorkItem(Item, Routine, Context)
Definition: exfuncs.h:265
#define _SEH2_YIELD(STMT_)
Definition: pseh2_64.h:8
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define STATUS_PENDING
Definition: ntstatus.h:82
#define IRP_MJ_FILE_SYSTEM_CONTROL
NTSTATUS VfatClose(PVFAT_IRP_CONTEXT IrpContext)
Definition: close.c:213
VOID vfatDestroyFCB(PVFATFCB pFCB)
Definition: fcb.c:269
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
VOID NTAPI IoFreeMdl(PMDL Mdl)
Definition: iomdl.c:146
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_DRIVER_INTERNAL_ERROR
Definition: udferr_usr.h:177
unsigned char UCHAR
Definition: xmlstorage.h:181
static NTSTATUS VfatLockControl(IN PVFAT_IRP_CONTEXT IrpContext)
Definition: misc.c:62
#define VCB_GOOD
Definition: vfat.h:247
#define IRP_MJ_CLOSE
Definition: rdpdr.c:45
#define InterlockedDecrement
Definition: armddk.h:52
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
NTSTATUS VfatFlush(PVFAT_IRP_CONTEXT IrpContext)
Definition: flush.c:149
UCHAR MinorFunction
Definition: vfat.h:584
NTSTATUS VfatSetVolumeInformation(PVFAT_IRP_CONTEXT IrpContext)
Definition: volume.c:509
BOOLEAN VfatCheckForDismount(IN PDEVICE_EXTENSION DeviceExt, IN BOOLEAN Force)
Definition: misc.c:417
NTSTATUS VfatFileSystemControl(PVFAT_IRP_CONTEXT IrpContext)
Definition: fsctl.c:1390
#define IO_TYPE_VPB
ClearFlag(Dirent->Flags, DIRENT_FLAG_NOT_PERSISTENT)
struct _VFATFCB * PVFATFCB
struct _VPB VPB
NTSTATUS NTAPI FsRtlProcessFileLock(IN PFILE_LOCK FileLock, IN PIRP Irp, IN PVOID Context OPTIONAL)
Definition: filelock.c:1153
Status
Definition: gdiplustypes.h:24
#define TAG_STATS
Definition: vfat.h:544
PMDL NTAPI IoAllocateMdl(IN PVOID VirtualAddress, IN ULONG Length, IN BOOLEAN SecondaryBuffer, IN BOOLEAN ChargeQuota, IN PIRP Irp)
Definition: iomdl.c:22
PVFAT_GLOBAL_DATA VfatGlobalData
Definition: iface.c:40
NTSTATUS VfatDirectoryControl(PVFAT_IRP_CONTEXT IrpContext)
Definition: dir.c:728
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2745
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1250
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
PFILE_OBJECT FileObject
Definition: iotypes.h:2812
_SEH2_END
Definition: create.c:4424
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define InterlockedIncrement
Definition: armddk.h:53
NTSTATUS VfatPnp(PVFAT_IRP_CONTEXT IrpContext)
Definition: pnp.c:20
VOID NTAPI MmProbeAndLockPages(IN PMDL Mdl, IN KPROCESSOR_MODE AccessMode, IN LOCK_OPERATION Operation)
Definition: mdlsup.c:935
enum _LOCK_OPERATION LOCK_OPERATION
NTSTATUS VfatRead(PVFAT_IRP_CONTEXT IrpContext)
Definition: rw.c:710
BOOLEAN NTAPI CcUninitializeCacheMap(IN PFILE_OBJECT FileObject, IN OPTIONAL PLARGE_INTEGER TruncateSize, IN OPTIONAL PCACHE_UNINITIALIZE_EVENT UninitializeEvent)
Definition: fssup.c:284
PDEVICE_OBJECT DeviceObject
Definition: vfat.h:578
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
UCHAR MajorFunction
Definition: vfat.h:583
#define IRP_MJ_LOCK_CONTROL
Definition: rdpdr.c:53
IN PVCB IN VBO IN ULONG OUT PBCB OUT PVOID IN BOOLEAN IN BOOLEAN Zero
Definition: fatprocs.h:402
#define DPRINT1
Definition: precomp.h:8
#define IRP_MJ_READ
Definition: rdpdr.c:46
ERESOURCE VolumeListLock
Definition: vfat.h:409
#define IRP_MJ_CLEANUP
Definition: iotypes.h:166
VOID NTAPI VfatHandleDeferredWrite(IN PVOID IrpContext, IN PVOID Unused)
Definition: misc.c:218
#define IRP_MJ_SET_INFORMATION
Definition: rdpdr.c:49
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:565
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
_In_ FLT_SET_CONTEXT_OPERATION Operation
Definition: fltkernel.h:1468
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
ULONG Flags
Definition: vfat.h:580
#define IRP_MJ_QUERY_INFORMATION
Definition: rdpdr.c:48
VOID NTAPI FsRtlNotifyUninitializeSync(IN PNOTIFY_SYNC *NotifySync)
Definition: notify.c:1639
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
_In_ PFCB Fcb
Definition: cdprocs.h:151
PIO_STACK_LOCATION Stack
Definition: vfat.h:582
return STATUS_SUCCESS
Definition: btrfs.c:2725
NTSTATUS VfatLockUserBuffer(IN PIRP Irp, IN ULONG Length, IN LOCK_OPERATION Operation)
Definition: misc.c:382
IoMarkIrpPending(Irp)
#define VPB_MOUNTED
Definition: iotypes.h:1763
BOOL Delete(LPCTSTR ServiceName)
Definition: delete.c:12
VOID NTAPI IoReleaseVpbSpinLock(IN KIRQL Irql)
Definition: volume.c:1212
static LONG QueueCount
Definition: misc.c:52
IN OUT PVCB IN PDEVICE_OBJECT IN PVPB Vpb
Definition: fatprocs.h:1664
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
WORK_QUEUE_ITEM WorkQueueItem
Definition: vfat.h:581
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52
_Inout_ PVCB _In_ BOOLEAN Force
Definition: cdprocs.h:1425