ReactOS 0.4.15-dev-8127-g6338913
fastio.c File Reference
#include "ext2fs.h"
Include dependency graph for fastio.c:

Go to the source code of this file.

Macros

#define FASTIO_DEBUG_LEVEL   DL_NVR
 

Functions

FAST_IO_POSSIBLE Ext2IsFastIoPossible (IN PEXT2_FCB Fcb)
 
BOOLEAN Ext2FastIoCheckIfPossible (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, IN BOOLEAN CheckForReadOperation, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
 
BOOLEAN Ext2FastIoRead (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
 
BOOLEAN Ext2FastIoWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
 
BOOLEAN Ext2FastIoQueryBasicInfo (IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, OUT PFILE_BASIC_INFORMATION Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
 
BOOLEAN Ext2FastIoQueryStandardInfo (IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, OUT PFILE_STANDARD_INFORMATION Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
 
BOOLEAN Ext2FastIoLock (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN PEPROCESS Process, IN ULONG Key, IN BOOLEAN FailImmediately, IN BOOLEAN ExclusiveLock, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
 
BOOLEAN Ext2FastIoUnlockSingle (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN PEPROCESS Process, IN ULONG Key, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
 
BOOLEAN Ext2FastIoUnlockAll (IN PFILE_OBJECT FileObject, IN PEPROCESS Process, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
 
BOOLEAN Ext2FastIoUnlockAllByKey (IN PFILE_OBJECT FileObject, IN PEPROCESS Process, IN ULONG Key, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
 
BOOLEAN Ext2FastIoQueryNetworkOpenInfo (IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, IN OUT PFILE_NETWORK_OPEN_INFORMATION PFNOI, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
 
VOID Ext2AcquireForCreateSection (IN PFILE_OBJECT FileObject)
 
VOID Ext2ReleaseForCreateSection (IN PFILE_OBJECT FileObject)
 
NTSTATUS Ext2AcquireFileForModWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER EndingOffset, OUT PERESOURCE *ResourceToRelease, IN PDEVICE_OBJECT DeviceObject)
 
NTSTATUS Ext2ReleaseFileForModWrite (IN PFILE_OBJECT FileObject, IN PERESOURCE ResourceToRelease, IN PDEVICE_OBJECT DeviceObject)
 
NTSTATUS Ext2AcquireFileForCcFlush (IN PFILE_OBJECT FileObject, IN PDEVICE_OBJECT DeviceObject)
 
NTSTATUS Ext2ReleaseFileForCcFlush (IN PFILE_OBJECT FileObject, IN PDEVICE_OBJECT DeviceObject)
 
NTSTATUS Ext2PreAcquireForCreateSection (IN PFS_FILTER_CALLBACK_DATA cd, OUT PVOID *cc)
 

Variables

PEXT2_GLOBAL Ext2Global
 

Macro Definition Documentation

◆ FASTIO_DEBUG_LEVEL

#define FASTIO_DEBUG_LEVEL   DL_NVR

Definition at line 20 of file fastio.c.

Function Documentation

◆ Ext2AcquireFileForCcFlush()

NTSTATUS Ext2AcquireFileForCcFlush ( IN PFILE_OBJECT  FileObject,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 1135 of file fastio.c.

1139{
1140 PEXT2_FCB Fcb = FileObject->FsContext;
1141
1142 if (Fcb->Header.Resource != NULL) {
1144 }
1145
1146 DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2AcquireFileForCcFlush: Fcb=%p\n", Fcb));
1147
1148 return STATUS_SUCCESS;
1149}
#define DEBUG(args)
Definition: rdesktop.h:129
_In_ PFCB Fcb
Definition: cdprocs.h:159
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FASTIO_DEBUG_LEVEL
Definition: fastio.c:20
#define ExAcquireResourceExclusiveLite(res, wait)
Definition: env_spec_w32.h:615
#define STATUS_SUCCESS
Definition: shellext.h:65
FSRTL_ADVANCED_FCB_HEADER Header
Definition: cdstruc.h:925
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:550

Referenced by DriverEntry().

◆ Ext2AcquireFileForModWrite()

NTSTATUS Ext2AcquireFileForModWrite ( IN PFILE_OBJECT  FileObject,
IN PLARGE_INTEGER  EndingOffset,
OUT PERESOURCE ResourceToRelease,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 1081 of file fastio.c.

1088{
1089 BOOLEAN ResourceAcquired = FALSE;
1090
1091 PEXT2_FCB Fcb = FileObject->FsContext;
1092
1093 *ResourceToRelease = Fcb->Header.Resource;
1095 if (!ResourceAcquired) {
1097 }
1098
1099 DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2AcquireFileForModWrite: Fcb=%p Acquired=%d\n",
1100 Fcb, ResourceAcquired));
1101
1102 return (ResourceAcquired ? STATUS_SUCCESS : STATUS_CANT_WAIT);
1103}
unsigned char BOOLEAN
#define FALSE
Definition: types.h:117
#define STATUS_CANT_WAIT
Definition: ntstatus.h:452
_In_ PLARGE_INTEGER _Out_ struct _ERESOURCE ** ResourceToRelease
Definition: iotypes.h:1598

Referenced by DriverEntry().

◆ Ext2AcquireForCreateSection()

VOID Ext2AcquireForCreateSection ( IN PFILE_OBJECT  FileObject)

Definition at line 1043 of file fastio.c.

1047{
1048 PEXT2_FCB Fcb = FileObject->FsContext;
1049
1050 if (Fcb->Header.Resource != NULL) {
1052 }
1053
1054 DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2AcquireForCreateSection: Fcb=%p\n", Fcb));
1055}

Referenced by DriverEntry().

◆ Ext2FastIoCheckIfPossible()

BOOLEAN Ext2FastIoCheckIfPossible ( IN PFILE_OBJECT  FileObject,
IN PLARGE_INTEGER  FileOffset,
IN ULONG  Length,
IN BOOLEAN  Wait,
IN ULONG  LockKey,
IN BOOLEAN  CheckForReadOperation,
OUT PIO_STATUS_BLOCK  IoStatus,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 64 of file fastio.c.

74{
75 BOOLEAN bPossible = FastIoIsNotPossible;
78 LARGE_INTEGER lLength;
79
80 lLength.QuadPart = Length;
81
82 _SEH2_TRY {
83
85
86 _SEH2_TRY {
87
90 }
91
92 Fcb = (PEXT2_FCB) FileObject->FsContext;
93 if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
95 }
96
98 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
99
100 /* do nothing if target fie was deleted */
103 }
104
105 if (IsDirectory(Fcb)) {
107 }
108
109 Ccb = (PEXT2_CCB) FileObject->FsContext2;
110 if (Ccb == NULL) {
112 }
113
115
116 bPossible = FsRtlFastCheckLockForRead(
117 &Fcb->FileLockAnchor,
119 &lLength,
120 LockKey,
123
124 } else {
125
126 if (!IsVcbReadOnly(Fcb->Vcb)) {
127 bPossible = FsRtlFastCheckLockForWrite(
128 &Fcb->FileLockAnchor,
130 &lLength,
131 LockKey,
134 }
135 }
136
137#if EXT2_DEBUG
138 DEBUG(DL_INF, ("Ext2FastIIOCheckPossible: %s %s %wZ\n",
140 "FASTIO_CHECK_IF_POSSIBLE",
141 &Fcb->Mcb->FullName
142 ));
143
144 DEBUG(DL_INF, (
145 "Ext2FastIIOCheckPossible: Offset: %I64xg Length: %xh Key: %u %s %s\n",
146 FileOffset->QuadPart,
147 Length,
148 LockKey,
149 (CheckForReadOperation ? "CheckForReadOperation:" :
150 "CheckForWriteOperation:"),
151 (bPossible ? "Succeeded" : "Failed")));
152#endif
153
155 bPossible = FastIoIsNotPossible;
156 } _SEH2_END;
157
158 } _SEH2_FINALLY {
159
161 } _SEH2_END;
162
163 return bPossible;
164}
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:160
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN PFCB _In_opt_ PCCB Ccb
Definition: cdprocs.h:592
#define Ext2GetCurrentProcessName()
Definition: ext2fs.h:1489
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
@ EXT2FCB
Definition: ext2fs.h:463
@ EXT2VCB
Definition: ext2fs.h:462
#define IsDirectory(Fcb)
Definition: ext2fs.h:283
#define IsVcbReadOnly(Vcb)
Definition: ext2fs.h:814
#define IsExt2FsDevice(DO)
Definition: ext2fs.h:616
#define DL_INF
Definition: ext2fs.h:1436
#define FCB_DELETE_PENDING
Definition: ext2fs.h:888
struct _EXT2_CCB * PEXT2_CCB
struct _EXT2_FCB * PEXT2_FCB
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG LockKey
Definition: fatprocs.h:2665
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN CheckForReadOperation
Definition: fatprocs.h:2666
BOOLEAN NTAPI FsRtlFastCheckLockForWrite(IN PFILE_LOCK FileLock, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN ULONG Key, IN PFILE_OBJECT FileObject, IN PVOID Process)
Definition: filelock.c:782
BOOLEAN NTAPI FsRtlFastCheckLockForRead(IN PFILE_LOCK FileLock, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN ULONG Key, IN PFILE_OBJECT FileObject, IN PVOID Process)
Definition: filelock.c:748
#define _SEH2_FINALLY
Definition: filesup.c:21
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
#define _SEH2_LEAVE
Definition: filesup.c:20
#define FsRtlEnterFileSystem
#define FsRtlExitFileSystem
@ FastIoIsNotPossible
Definition: fsrtltypes.h:240
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
if(dx< 0)
Definition: linetemp.h:194
#define ASSERT(a)
Definition: mode.c:44
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:66
ULONG Type
Definition: ntfs.h:95
ULONG Size
Definition: ntfs.h:96
ULONG Flags
Definition: ntfs.h:536
PVCB Vcb
Definition: cdstruc.h:933
CD_MCB Mcb
Definition: cdstruc.h:1016
NTFSIDENTIFIER Identifier
Definition: ntfs.h:515
LONGLONG QuadPart
Definition: typedefs.h:114
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define PsGetCurrentProcess
Definition: psfuncs.h:17

Referenced by DriverEntry().

◆ Ext2FastIoLock()

BOOLEAN Ext2FastIoLock ( IN PFILE_OBJECT  FileObject,
IN PLARGE_INTEGER  FileOffset,
IN PLARGE_INTEGER  Length,
IN PEPROCESS  Process,
IN ULONG  Key,
IN BOOLEAN  FailImmediately,
IN BOOLEAN  ExclusiveLock,
OUT PIO_STATUS_BLOCK  IoStatus,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 517 of file fastio.c.

528{
531
532 _SEH2_TRY {
533
535
536 _SEH2_TRY {
537
541 }
542
543 Fcb = (PEXT2_FCB) FileObject->FsContext;
544 if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
547 }
548
550 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
551
552 if (IsDirectory(Fcb)) {
553 DbgBreak();
556 }
557#if EXT2_DEBUG
558 DEBUG(DL_INF, (
559 "Ext2FastIoLock: %s %s %wZ\n",
561 "FASTIO_LOCK",
562 &Fcb->Mcb->FullName ));
563
564 DEBUG(DL_INF, (
565 "Ext2FastIoLock: Offset: %I64xh Length: %I64xh Key: %u %s%s\n",
566 FileOffset->QuadPart,
567 Length->QuadPart,
568 Key,
569 (FailImmediately ? "FailImmediately " : ""),
570 (ExclusiveLock ? "ExclusiveLock " : "") ));
571#endif
572
573 if (!FsRtlOplockIsFastIoPossible(&Fcb->Oplock)) {
575 }
576
578 &Fcb->FileLockAnchor,
581 Length,
582 Process,
583 Key,
586 IoStatus,
587 NULL,
588 FALSE);
589
590 if (Status) {
591 Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
592 }
593
596 } _SEH2_END;
597
598 } _SEH2_FINALLY {
599
601 } _SEH2_END;
602
603#if EXT2_DEBUG
604 if (Status == FALSE) {
605 DEBUG(DL_ERR, (
606 "Ext2FastIoLock: %s %s *** Status: FALSE ***\n",
608 "FASTIO_LOCK"
609 ));
610 } else if (IoStatus->Status != STATUS_SUCCESS) {
611 DEBUG(DL_ERR, (
612 "Ext2FastIoLock: %s %s *** Status: %s (%#x) ***\n",
614 "FASTIO_LOCK",
616 IoStatus->Status
617 ));
618 }
619#endif
620
621 return Status;
622}
FAST_IO_POSSIBLE Ext2IsFastIoPossible(IN PEXT2_FCB Fcb)
Definition: fastio.c:38
ULONG ProcessNameOffset
#define DbgBreak()
Definition: ext2fs.h:46
#define DL_ERR
Definition: ext2fs.h:1434
PUCHAR Ext2NtStatusToString(IN NTSTATUS Status)
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN BOOLEAN ExclusiveLock
Definition: fatprocs.h:2714
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN FailImmediately
Definition: fatprocs.h:2713
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
#define FsRtlFastLock(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)
Definition: fsrtlfuncs.h:1581
Status
Definition: gdiplustypes.h:25
__in UCHAR __in POWER_STATE __in_opt PVOID __in PIO_STATUS_BLOCK IoStatus
Definition: mxum.h:159
BOOLEAN NTAPI FsRtlOplockIsFastIoPossible(IN POPLOCK Oplock)
Definition: oplock.c:1564
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
unsigned char * PUCHAR
Definition: typedefs.h:53
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135

Referenced by DriverEntry().

◆ Ext2FastIoQueryBasicInfo()

BOOLEAN Ext2FastIoQueryBasicInfo ( IN PFILE_OBJECT  FileObject,
IN BOOLEAN  Wait,
OUT PFILE_BASIC_INFORMATION  Buffer,
OUT PIO_STATUS_BLOCK  IoStatus,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 280 of file fastio.c.

286{
291 BOOLEAN FcbMainResourceAcquired = FALSE;
292
293 _SEH2_TRY {
294
296
297 _SEH2_TRY {
298
302 }
303
304 Fcb = (PEXT2_FCB) FileObject->FsContext;
305 if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
308 }
309 Ccb = (PEXT2_CCB) FileObject->FsContext2;
310 Mcb = Fcb->Mcb;
312 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
313#if EXT2_DEBUG
314 DEBUG(DL_INF, (
315 "Ext2FastIoQueryBasicInfo: %s %s %wZ\n",
317 "FASTIO_QUERY_BASIC_INFO",
318 &Fcb->Mcb->FullName
319 ));
320#endif
324 Wait)) {
326 }
327 FcbMainResourceAcquired = TRUE;
328 }
329
331
332 /*
333 typedef struct _FILE_BASIC_INFORMATION {
334 LARGE_INTEGER CreationTime;
335 LARGE_INTEGER LastAccessTime;
336 LARGE_INTEGER LastWriteTime;
337 LARGE_INTEGER ChangeTime;
338 ULONG FileAttributes;
339 } FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
340 */
341
342 Buffer->CreationTime = Mcb->CreationTime;
343 Buffer->LastAccessTime = Mcb->LastAccessTime;
344 Buffer->LastWriteTime = Mcb->LastWriteTime;
345 Buffer->ChangeTime = Mcb->ChangeTime;
346 Buffer->FileAttributes = Mcb->FileAttr;
347 if (Buffer->FileAttributes == 0) {
348 Buffer->FileAttributes = FILE_ATTRIBUTE_NORMAL;
349 }
350
351 IoStatus->Information = sizeof(FILE_BASIC_INFORMATION);
352 IoStatus->Status = STATUS_SUCCESS;
353
354 Status = TRUE;
355
358 } _SEH2_END;
359
360 } _SEH2_FINALLY {
361
362 if (FcbMainResourceAcquired) {
364 }
365
367 } _SEH2_END;
368
369#if EXT2_DEBUG
370
371 if (Status == FALSE) {
372
373 DEBUG(DL_ERR, ("Ext2FastIoQueryBasicInfo: %s %s Status: FALSE ***\n",
375 "FASTIO_QUERY_BASIC_INFO"));
376
377 } else if (IoStatus->Status != STATUS_SUCCESS) {
378
379 DEBUG(DL_ERR, (
380 "Ext2FastIoQueryBasicInfo: %s %s Status: %#x ***\n",
382 "FASTIO_QUERY_BASIC_INFO",
383 IoStatus->Status
384 ));
385 }
386#endif
387
388 return Status;
389}
Definition: bufpool.h:45
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
BOOLEAN Ext2FastIoQueryBasicInfo(IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, OUT PFILE_BASIC_INFORMATION Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:280
#define ExAcquireResourceSharedLite(res, wait)
Definition: env_spec_w32.h:621
#define FCB_PAGE_FILE
Definition: ext2fs.h:881
struct _EXT2_FCB EXT2_FCB
#define IsFlagOn(a, b)
Definition: ext2fs.h:177
IN PVCB IN ULONG IN OUT PULONG IN BOOLEAN OUT PLARGE_MCB Mcb
Definition: fatprocs.h:348
#define FILE_BASIC_INFORMATION
Definition: disk.h:53
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1822
ERESOURCE MainResource
Definition: ntfs.h:528
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
_In_ WDFDPC _In_ BOOLEAN Wait
Definition: wdfdpc.h:170

Referenced by DriverEntry(), and Ext2FastIoQueryBasicInfo().

◆ Ext2FastIoQueryNetworkOpenInfo()

BOOLEAN Ext2FastIoQueryNetworkOpenInfo ( IN PFILE_OBJECT  FileObject,
IN BOOLEAN  Wait,
IN OUT PFILE_NETWORK_OPEN_INFORMATION  PFNOI,
OUT PIO_STATUS_BLOCK  IoStatus,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 942 of file fastio.c.

949{
953
954 BOOLEAN bResult = FALSE;
955 BOOLEAN FcbResourceAcquired = FALSE;
956
957 _SEH2_TRY {
958
960
964 }
965
966 Fcb = (PEXT2_FCB) FileObject->FsContext;
967 if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
968 DbgBreak();
971 }
972
974 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
975 Ccb = (PEXT2_CCB) FileObject->FsContext2;
976 Mcb = Fcb->Mcb;
977
978#if EXT2_DEBUG
979 DEBUG(DL_INF, (
980 "%-31s %wZ\n",
981 "FASTIO_QUERY_NETWORK_OPEN_INFO",
982 &Fcb->Mcb->FullName
983 ));
984#endif
985
986 if (!Ccb) {
988 }
989
991
994 Wait
995 )) {
997 }
998
999 FcbResourceAcquired = TRUE;
1000 }
1001
1002 if (IsDirectory(Fcb)) {
1003 PFNOI->AllocationSize.QuadPart = 0;
1004 PFNOI->EndOfFile.QuadPart = 0;
1005 } else {
1006 PFNOI->AllocationSize = Fcb->Header.AllocationSize;
1007 PFNOI->EndOfFile = Fcb->Header.FileSize;
1008 }
1009
1010 PFNOI->FileAttributes = Mcb->FileAttr;
1011 if (PFNOI->FileAttributes == 0) {
1012 PFNOI->FileAttributes = FILE_ATTRIBUTE_NORMAL;
1013 }
1014
1015 PFNOI->CreationTime = Mcb->CreationTime;
1016 PFNOI->LastAccessTime = Mcb->LastAccessTime;
1017 PFNOI->LastWriteTime = Mcb->LastWriteTime;
1018 PFNOI->ChangeTime = Mcb->ChangeTime;
1019
1020 bResult = TRUE;
1021
1022 IoStatus->Status = STATUS_SUCCESS;
1023 IoStatus->Information = sizeof(FILE_NETWORK_OPEN_INFORMATION);
1024
1025 } _SEH2_FINALLY {
1026
1027 if (FcbResourceAcquired) {
1029 }
1030
1032 } _SEH2_END;
1033
1034 return bResult;
1035}
#define EXT2_DEBUG
Definition: ext2fs.h:34
struct _FILE_NETWORK_OPEN_INFORMATION FILE_NETWORK_OPEN_INFORMATION

◆ Ext2FastIoQueryStandardInfo()

BOOLEAN Ext2FastIoQueryStandardInfo ( IN PFILE_OBJECT  FileObject,
IN BOOLEAN  Wait,
OUT PFILE_STANDARD_INFORMATION  Buffer,
OUT PIO_STATUS_BLOCK  IoStatus,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 396 of file fastio.c.

403{
404
408 BOOLEAN FcbMainResourceAcquired = FALSE;
409
410 _SEH2_TRY {
411
413
414 _SEH2_TRY {
415
419 }
420
421 Fcb = (PEXT2_FCB) FileObject->FsContext;
422 if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
425 }
426
428 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
429
430#if EXT2_DEBUG
431 DEBUG(DL_INF, (
432 "Ext2FastIoQueryStandardInfo: %s %s %wZ\n",
434 "FASTIO_QUERY_STANDARD_INFO",
435 &Fcb->Mcb->FullName ));
436#endif
437 Vcb = Fcb->Vcb;
438
442 Wait )) {
444 }
445 FcbMainResourceAcquired = TRUE;
446 }
447
449
450 /*
451 typedef struct _FILE_STANDARD_INFORMATION {
452 LARGE_INTEGER AllocationSize;
453 LARGE_INTEGER EndOfFile;
454 ULONG NumberOfLinks;
455 BOOLEAN DeletePending;
456 BOOLEAN Directory;
457 } FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION;
458 */
459
460 Buffer->NumberOfLinks = Fcb->Inode->i_nlink;
461 Buffer->DeletePending = IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING);
462
463 if (IsDirectory(Fcb)) {
464 Buffer->Directory = IsDirectory(Fcb);
465 Buffer->AllocationSize.QuadPart = 0;
466 Buffer->EndOfFile.QuadPart = 0;
467 } else {
468 Buffer->Directory = FALSE;
469 Buffer->AllocationSize = Fcb->Header.AllocationSize;
470 Buffer->EndOfFile = Fcb->Header.FileSize;
471 }
472
473 IoStatus->Information = sizeof(FILE_STANDARD_INFORMATION);
474 IoStatus->Status = STATUS_SUCCESS;
475#if EXT2_DEBUG
476 DEBUG(DL_INF, ( "Ext2FastIoQueryStandInfo: AllocatieonSize = %I64xh FileSize = %I64xh\n",
477 Buffer->AllocationSize.QuadPart, Buffer->EndOfFile.QuadPart));
478#endif
479 Status = TRUE;
480
483 } _SEH2_END;
484
485 } _SEH2_FINALLY {
486
487 if (FcbMainResourceAcquired) {
489 }
490
492 } _SEH2_END;
493
494#if EXT2_DEBUG
495 if (Status == FALSE) {
496 DEBUG(DL_INF, (
497 "Ext2FastIoQueryStandardInfo: %s %s Status: FALSE ***\n",
499 "FASTIO_QUERY_STANDARD_INFO" ));
500 } else if (IoStatus->Status != STATUS_SUCCESS) {
501 DEBUG(DL_INF, (
502 "Ext2FastIoQueryStandardInfo: %s %s Status: %#x ***\n",
504 "FASTIO_QUERY_STANDARD_INFO",
505 IoStatus->Status ));
506 }
507#endif
508
509 return Status;
510}
#define FILE_STANDARD_INFORMATION
Definition: disk.h:54
#define Vcb
Definition: cdprocs.h:1415

Referenced by DriverEntry().

◆ Ext2FastIoRead()

BOOLEAN Ext2FastIoRead ( IN PFILE_OBJECT  FileObject,
IN PLARGE_INTEGER  FileOffset,
IN ULONG  Length,
IN BOOLEAN  Wait,
IN ULONG  LockKey,
OUT PVOID  Buffer,
OUT PIO_STATUS_BLOCK  IoStatus,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 172 of file fastio.c.

180{
183
184 Fcb = (PEXT2_FCB) FileObject->FsContext;
185 if (Fcb == NULL) {
186 return FALSE;
187 }
188
190 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
191
195
196 DEBUG(DL_IO, ("Ext2FastIoRead: %wZ Offset: %I64xh Length: %xh Key: %u Status: %d\n",
197 &Fcb->Mcb->ShortName, FileOffset->QuadPart, Length, LockKey, Status));
198
199 return Status;
200}
#define DL_IO
Definition: ext2fs.h:1450
BOOLEAN NTAPI FsRtlCopyRead(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:64

Referenced by DriverEntry().

◆ Ext2FastIoUnlockAll()

BOOLEAN Ext2FastIoUnlockAll ( IN PFILE_OBJECT  FileObject,
IN PEPROCESS  Process,
OUT PIO_STATUS_BLOCK  IoStatus,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 736 of file fastio.c.

741{
744
745 _SEH2_TRY {
746
748
749 _SEH2_TRY {
750
754 }
755
756 Fcb = (PEXT2_FCB) FileObject->FsContext;
757 if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
758 DbgBreak();
761 }
762
764 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
765
766 if (IsDirectory(Fcb)) {
767 DbgBreak();
770 }
771#if EXT2_DEBUG
772 DEBUG(DL_INF, (
773 "Ext2FastIoUnlockSingle: %s %s %wZ\n",
775 "FASTIO_UNLOCK_ALL",
776 &Fcb->Mcb->FullName
777 ));
778#endif
779
780 if (!FsRtlOplockIsFastIoPossible(&Fcb->Oplock)) {
782 }
783
785 &Fcb->FileLockAnchor,
787 Process,
788 NULL );
789
790 IoStatus->Information = 0;
791 Status = TRUE;
792
793 Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
794
797 } _SEH2_END;
798
799 } _SEH2_FINALLY {
800
802 } _SEH2_END;
803
804#if EXT2_DEBUG
805 if (Status == FALSE) {
806
807 DEBUG(DL_ERR, (
808 "Ext2FastIoUnlockSingle: %s %s *** Status: FALSE ***\n",
810 "FASTIO_UNLOCK_ALL"
811 ));
812 } else if (IoStatus->Status != STATUS_SUCCESS) {
813 DEBUG(DL_ERR, (
814 "Ext2FastIoUnlockSingle: %s %s *** Status: %s (%#x) ***\n",
816 "FASTIO_UNLOCK_ALL",
818 IoStatus->Status
819 ));
820 }
821#endif
822
823 return Status;
824}
NTSTATUS NTAPI FsRtlFastUnlockAll(IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PEPROCESS Process, IN PVOID Context OPTIONAL)
Definition: filelock.c:1025

Referenced by DriverEntry().

◆ Ext2FastIoUnlockAllByKey()

BOOLEAN Ext2FastIoUnlockAllByKey ( IN PFILE_OBJECT  FileObject,
IN PEPROCESS  Process,
IN ULONG  Key,
OUT PIO_STATUS_BLOCK  IoStatus,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 831 of file fastio.c.

842{
845
846 _SEH2_TRY {
847
849
850 _SEH2_TRY {
851
855 }
856
857 Fcb = (PEXT2_FCB) FileObject->FsContext;
858 if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
859 DbgBreak();
862 }
863
865 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
866
867 if (IsDirectory(Fcb)) {
868 DbgBreak();
871 }
872
873#if EXT2_DEBUG
874 DEBUG(DL_INF, (
875 "Ext2FastIoUnlockAllByKey: %s %s %wZ\n",
877 "FASTIO_UNLOCK_ALL_BY_KEY",
878 &Fcb->Mcb->FullName
879 ));
880
881 DEBUG(DL_INF, (
882 "Ext2FastIoUnlockAllByKey: Key: %u\n",
883 Key
884 ));
885#endif
886
887 if (!FsRtlOplockIsFastIoPossible(&Fcb->Oplock)) {
889 }
890
892 &Fcb->FileLockAnchor,
894 Process,
895 Key,
896 NULL
897 );
898
899 IoStatus->Information = 0;
900 Status = TRUE;
901
902 Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
903
906 } _SEH2_END;
907
908 } _SEH2_FINALLY {
909
911 } _SEH2_END;
912
913#if EXT2_DEBUG
914 if (Status == FALSE) {
915
916 DEBUG(DL_ERR, (
917 "Ext2FastIoUnlockAllByKey: %s %s *** Status: FALSE ***\n",
919 "FASTIO_UNLOCK_ALL_BY_KEY"
920 ));
921 } else if (IoStatus->Status != STATUS_SUCCESS) {
922
923 DEBUG(DL_ERR, (
924 "Ext2FastIoUnlockAllByKey: %s %s *** Status: %s (%#x) ***\n",
926 "FASTIO_UNLOCK_ALL_BY_KEY",
928 IoStatus->Status
929 ));
930 }
931#endif
932
933 return Status;
934}
NTSTATUS NTAPI FsRtlFastUnlockAllByKey(IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PEPROCESS Process, IN ULONG Key, IN PVOID Context OPTIONAL)
Definition: filelock.c:1086

Referenced by DriverEntry().

◆ Ext2FastIoUnlockSingle()

BOOLEAN Ext2FastIoUnlockSingle ( IN PFILE_OBJECT  FileObject,
IN PLARGE_INTEGER  FileOffset,
IN PLARGE_INTEGER  Length,
IN PEPROCESS  Process,
IN ULONG  Key,
OUT PIO_STATUS_BLOCK  IoStatus,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 629 of file fastio.c.

638{
641
642 _SEH2_TRY {
643
645
646 _SEH2_TRY {
647
651 }
652
653 Fcb = (PEXT2_FCB) FileObject->FsContext;
654 if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
655 DbgBreak();
658 }
659
661 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
662
663 if (IsDirectory(Fcb)) {
664 DbgBreak();
667 }
668
669#if EXT2_DEBUG
670 DEBUG(DL_INF, (
671 "Ext2FastIoUnlockSingle: %s %s %wZ\n",
673 "FASTIO_UNLOCK_SINGLE",
674 &Fcb->Mcb->FullName ));
675
676 DEBUG(DL_INF, (
677 "Ext2FastIoUnlockSingle: Offset: %I64xh Length: %I64xh Key: %u\n",
678 FileOffset->QuadPart,
679 Length->QuadPart,
680 Key ));
681#endif
682
683 if (!FsRtlOplockIsFastIoPossible(&Fcb->Oplock)) {
685 }
686
688 &Fcb->FileLockAnchor,
691 Length,
692 Process,
693 Key,
694 NULL,
695 FALSE);
696
697 IoStatus->Information = 0;
698 Status = TRUE;
699
700 Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
701
704 } _SEH2_END;
705
706 } _SEH2_FINALLY {
707
709 } _SEH2_END;
710
711#if EXT2_DEBUG
712 if (Status == FALSE) {
713
714 DEBUG(DL_ERR, (
715 "Ext2FastIoUnlockSingle: %s %s *** Status: FALSE ***\n",
717 "FASTIO_UNLOCK_SINGLE" ));
718 } else if (IoStatus->Status != STATUS_SUCCESS) {
719 DEBUG(DL_ERR, (
720 "Ext2FastIoUnlockSingle: %s %s *** Status: %s (%#x) ***\n",
722 "FASTIO_UNLOCK_SINGLE",
724 IoStatus->Status ));
725 }
726#endif
727
728 return Status;
729}
NTSTATUS NTAPI FsRtlFastUnlockSingle(IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN PEPROCESS Process, IN ULONG Key, IN PVOID Context OPTIONAL, IN BOOLEAN AlreadySynchronized)
Definition: filelock.c:825

Referenced by DriverEntry().

◆ Ext2FastIoWrite()

BOOLEAN Ext2FastIoWrite ( IN PFILE_OBJECT  FileObject,
IN PLARGE_INTEGER  FileOffset,
IN ULONG  Length,
IN BOOLEAN  Wait,
IN ULONG  LockKey,
OUT PVOID  Buffer,
OUT PIO_STATUS_BLOCK  IoStatus,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 207 of file fastio.c.

216{
220
221 Fcb = (PEXT2_FCB) FileObject->FsContext;
222 if (Fcb == NULL)
223 return FALSE;
224
225 _SEH2_TRY {
226
228
230 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
231
232 if (IsVcbReadOnly(Fcb->Vcb)) {
234 }
235
236 if (!ExAcquireResourceSharedLite(Fcb->Header.Resource, Wait)) {
238 }
239 Locked = TRUE;
240
242 Fcb->Header.ValidDataLength.QuadPart < FileOffset->QuadPart + Length ||
243 Fcb->Header.FileSize.QuadPart < FileOffset->QuadPart + Length ) {
244 Status = FALSE;
246 }
247
248 if (Locked) {
250 Locked = FALSE;
251 }
252
255 if (Status) {
256 if (IoStatus)
257 Length = (ULONG)IoStatus->Information;
258 }
259
260 } _SEH2_FINALLY {
261
262 if (Locked) {
264 }
265
267 } _SEH2_END;
268
269 DEBUG(DL_IO, ("Ext2FastIoWrite: %wZ Offset: %I64xh Length: %xh Key: %xh Status=%d\n",
270 &Fcb->Mcb->ShortName, FileOffset->QuadPart, Length, LockKey, Status));
271
272 return Status;
273}
#define IsWritingToEof(Pos)
Definition: ext2fs.h:280
_In_ PMEMORY_AREA _In_ PVOID _In_ BOOLEAN Locked
Definition: newmm.h:209
BOOLEAN NTAPI FsRtlCopyWrite(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:264
uint32_t ULONG
Definition: typedefs.h:59

Referenced by DriverEntry().

◆ Ext2IsFastIoPossible()

FAST_IO_POSSIBLE Ext2IsFastIoPossible ( IN PEXT2_FCB  Fcb)

Definition at line 38 of file fastio.c.

41{
43
44 if (!Fcb || !FsRtlOplockIsFastIoPossible(&Fcb->Oplock))
45 return IsPossible;
46
47 IsPossible = FastIoIsQuestionable;
48
49 if (!FsRtlAreThereCurrentFileLocks(&Fcb->FileLockAnchor)) {
50 if (!IsVcbReadOnly(Fcb->Vcb) && !FlagOn(Fcb->Vcb->Flags, VCB_VOLUME_LOCKED)) {
51 IsPossible = FastIoIsPossible;
52 }
53 }
54
55 return IsPossible;
56}
#define VCB_VOLUME_LOCKED
Definition: ext2fs.h:789
#define FsRtlAreThereCurrentFileLocks(FL)
Definition: fsrtlfuncs.h:1584
@ FastIoIsQuestionable
Definition: fsrtltypes.h:242
@ FastIoIsPossible
Definition: fsrtltypes.h:241
enum _FAST_IO_POSSIBLE FAST_IO_POSSIBLE

Referenced by Ext2Cleanup(), Ext2FastIoLock(), Ext2FastIoUnlockAll(), Ext2FastIoUnlockAllByKey(), Ext2FastIoUnlockSingle(), Ext2LockControl(), Ext2OplockRequest(), Ext2ReadFile(), Ext2SetFileInformation(), and Ext2WriteFile().

◆ Ext2PreAcquireForCreateSection()

NTSTATUS Ext2PreAcquireForCreateSection ( IN PFS_FILTER_CALLBACK_DATA  cd,
OUT PVOID cc 
)

Definition at line 1178 of file fastio.c.

1182{
1183 PEXT2_FCB Fcb = (PEXT2_FCB)cd->FileObject->FsContext;
1185
1188 if (cd->Parameters.AcquireForSectionSynchronization.SyncType != SyncTypeCreateSection) {
1190 } else if (Fcb->ShareAccess.Writers == 0) {
1192 } else {
1194 }
1195
1196 return status;
1197}
InitDirComponents & cd
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_FILE_LOCKED_WITH_ONLY_READERS
Definition: ntstatus.h:111
#define STATUS_FILE_LOCKED_WITH_WRITERS
Definition: ntstatus.h:112
#define STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY
Definition: ntstatus.h:110
SHARE_ACCESS ShareAccess
Definition: cdstruc.h:1009
ULONG Writers
Definition: iotypes.h:527
Definition: ps.c:97
@ SyncTypeCreateSection
Definition: iotypes.h:7365
#define FS_FILTER_ACQUIRE_FOR_SECTION_SYNCHRONIZATION
Definition: iotypes.h:7398

Referenced by DriverEntry().

◆ Ext2ReleaseFileForCcFlush()

NTSTATUS Ext2ReleaseFileForCcFlush ( IN PFILE_OBJECT  FileObject,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 1156 of file fastio.c.

1160{
1161 PEXT2_FCB Fcb = FileObject->FsContext;
1162
1163 DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2ReleaseFileForCcFlush: Fcb=%p\n", Fcb));
1164
1165 if (Fcb->Header.Resource != NULL) {
1166 ExReleaseResourceLite(Fcb->Header.Resource);
1167 }
1168
1169 return STATUS_SUCCESS;
1170}

Referenced by DriverEntry().

◆ Ext2ReleaseFileForModWrite()

NTSTATUS Ext2ReleaseFileForModWrite ( IN PFILE_OBJECT  FileObject,
IN PERESOURCE  ResourceToRelease,
IN PDEVICE_OBJECT  DeviceObject 
)

Definition at line 1110 of file fastio.c.

1115{
1116 PEXT2_FCB Fcb = FileObject->FsContext;
1117
1118 DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2ReleaseFileForModWrite: Fcb=%p\n", Fcb));
1119
1120 if (ResourceToRelease != NULL) {
1121 ASSERT(ResourceToRelease == Fcb->Header.Resource);
1123 } else {
1124 DbgBreak();
1125 }
1126
1127 return STATUS_SUCCESS;
1128}

Referenced by DriverEntry().

◆ Ext2ReleaseForCreateSection()

VOID Ext2ReleaseForCreateSection ( IN PFILE_OBJECT  FileObject)

Definition at line 1062 of file fastio.c.

1065{
1066 PEXT2_FCB Fcb = FileObject->FsContext;
1067
1068 DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2ReleaseForCreateSection: Fcb=%p\n", Fcb));
1069
1070 if (Fcb->Header.Resource != NULL) {
1071 ExReleaseResourceLite(Fcb->Header.Resource);
1072 }
1073}

Referenced by DriverEntry().

Variable Documentation

◆ Ext2Global

PEXT2_GLOBAL Ext2Global
extern

Definition at line 16 of file init.c.