#include <rx.h>#include <pseh/pseh2.h>#include <limits.h>#include <dfs.h>#include <copysup.h>#include <debug.h>
Include dependency graph for rdbss.c:
Go to the source code of this file.
Classes | |
| struct | _RX_FSD_DISPATCH_VECTOR |
Macros | |
| #define | NDEBUG |
| #define | RX_TOPLEVELCTX_FLAG_FROM_POOL 1 |
| #define | ALLSCR_LENGTH (sizeof(L"all.scr") - sizeof(UNICODE_NULL)) |
| #define | BugCheckFileId RDBSS_BUG_CHECK_CLEANUP |
| #define | BugCheckFileId RDBSS_BUG_CHECK_CLOSE |
| #define | SET_SIZE_AND_QUERY(AlreadyConsummed, Function) |
| #define | _SEH2_TRY_RETURN(S) S; goto try_exit |
| #define | _SEH2_TRY_RETURN(S) S; goto try_exit |
| #define | BugCheckFileId RDBSS_BUG_CHECK_CACHESUP |
| #define | FILE_ATTRIBUTE_VOLUME 0x8 |
| #define | VALID_FILE_ATTRIBUTES |
| #define | VALID_DIR_ATTRIBUTES (VALID_FILE_ATTRIBUTES | FILE_ATTRIBUTE_DIRECTORY) |
Typedefs | |
| typedef NTSTATUS(NTAPI * | PRX_FSD_DISPATCH) (PRX_CONTEXT Context) |
| typedef struct _RX_FSD_DISPATCH_VECTOR | RX_FSD_DISPATCH_VECTOR |
| typedef struct _RX_FSD_DISPATCH_VECTOR * | PRX_FSD_DISPATCH_VECTOR |
Macro Definition Documentation
◆ _SEH2_TRY_RETURN [1/2]
◆ _SEH2_TRY_RETURN [2/2]
◆ ALLSCR_LENGTH
| #define ALLSCR_LENGTH (sizeof(L"all.scr") - sizeof(UNICODE_NULL)) |
◆ BugCheckFileId [1/3]
| #define BugCheckFileId RDBSS_BUG_CHECK_CLEANUP |
◆ BugCheckFileId [2/3]
| #define BugCheckFileId RDBSS_BUG_CHECK_CLOSE |
◆ BugCheckFileId [3/3]
| #define BugCheckFileId RDBSS_BUG_CHECK_CACHESUP |
◆ FILE_ATTRIBUTE_VOLUME
| #define FILE_ATTRIBUTE_VOLUME 0x8 |
◆ NDEBUG
◆ RX_TOPLEVELCTX_FLAG_FROM_POOL
◆ SET_SIZE_AND_QUERY
Value:
_In_ CDROM_SCAN_FOR_SPECIAL_INFO _In_ PCDROM_SCAN_FOR_SPECIAL_HANDLER Function
Definition: cdrom.h:1156
Definition: bufpool.h:45
Definition: compobj.c:4795
◆ VALID_DIR_ATTRIBUTES
| #define VALID_DIR_ATTRIBUTES (VALID_FILE_ATTRIBUTES | FILE_ATTRIBUTE_DIRECTORY) |
◆ VALID_FILE_ATTRIBUTES
| #define VALID_FILE_ATTRIBUTES |
Value:
( \
#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED
Definition: ntifs_ex.h:384
#define FILE_ATTRIBUTE_VOLUME
#define FILE_ATTRIBUTE_INTEGRITY_STREAM
Typedef Documentation
◆ PRX_FSD_DISPATCH
| typedef NTSTATUS(NTAPI * PRX_FSD_DISPATCH) (PRX_CONTEXT Context) |
◆ PRX_FSD_DISPATCH_VECTOR
◆ RX_FSD_DISPATCH_VECTOR
Function Documentation
◆ __RxInitializeTopLevelIrpContext()
| VOID __RxInitializeTopLevelIrpContext | ( | IN OUT PRX_TOPLEVELIRP_CONTEXT | TopLevelContext, |
| IN PIRP | Irp, | ||
| IN PRDBSS_DEVICE_OBJECT | RxDeviceObject, | ||
| IN ULONG | Flags | ||
| ) |
Definition at line 674 of file rdbss.c.
679{
680 DPRINT("__RxInitializeTopLevelIrpContext(%p, %p, %p, %u)\n", TopLevelContext, Irp, RxDeviceObject, Flags);
681
683 TopLevelContext->Irp = Irp;
685 TopLevelContext->Signature = RX_TOPLEVELIRP_CONTEXT_SIGNATURE;
686 TopLevelContext->RxDeviceObject = RxDeviceObject;
687 TopLevelContext->Previous = IoGetTopLevelIrp();
688 TopLevelContext->Thread = PsGetCurrentThread();
689
690 /* We cannot add to list something that'd come from stack */
692 {
693 RxAddToTopLevelIrpAllocatedContextsList(TopLevelContext);
694 }
695}
VOID RxAddToTopLevelIrpAllocatedContextsList(PRX_TOPLEVELIRP_CONTEXT TopLevelContext)
Definition: rdbss.c:752
Definition: rxcontx.h:7
Referenced by RxTryToBecomeTheTopLevelIrp().
◆ __RxWriteReleaseResources()
| VOID __RxWriteReleaseResources | ( | PRX_CONTEXT | RxContext, |
| BOOLEAN | ResourceOwnerSet, | ||
| ULONG | LineNumber, | ||
| PCSTR | FileName, | ||
| ULONG | SerialNumber | ||
| ) |
Definition at line 701 of file rdbss.c.
707{
708 RxCaptureFcb;
709
710 PAGED_CODE();
711
714
715 /* If FCB resource was acquired, release it */
717 {
718 /* Taking care of owner */
719 if (ResourceOwnerSet)
720 {
722 }
723 else
724 {
726 }
727
729 }
730
731 /* If FCB paging resource was acquired, release it */
733 {
734 /* Taking care of owner */
735 if (ResourceOwnerSet)
736 {
737 RxReleasePagingIoResourceForThread(RxContext, capFcb, RxContext->LowIoContext.ResourceThreadId);
738 }
739 else
740 {
742 }
743
744 /* No need to release boolean here, RxReleasePagingIoResource() takes care of it */
745 }
746}
#define RxReleasePagingIoResourceForThread(RxContext, Fcb, Thread)
Definition: rxprocs.h:276
BOOLEAN FcbPagingIoResourceAcquired
Definition: rxcontx.h:126
◆ _RxAllocatePoolWithTag()
| PVOID NTAPI _RxAllocatePoolWithTag | ( | _In_ POOL_TYPE | PoolType, |
| _In_ SIZE_T | NumberOfBytes, | ||
| _In_ ULONG | Tag | ||
| ) |
Definition at line 8941 of file rxce.c.
8945{
8947}
PVOID NTAPI ExAllocatePoolWithTagPriority(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag, IN EX_POOL_PRIORITY Priority)
Definition: expool.c:2963
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ _Strict_type_match_ POOL_TYPE PoolType
Definition: wdfdevice.h:3815
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS _Inout_ PLARGE_INTEGER NumberOfBytes
Definition: iotypes.h:1036
◆ _RxFreePool()
◆ _RxFreePoolWithTag()
◆ CheckForLoudOperations()
| VOID CheckForLoudOperations | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 647 of file rdbss.c.
649{
650 RxCaptureFcb;
651
652 PAGED_CODE();
653
654#define ALLSCR_LENGTH (sizeof(L"all.scr") - sizeof(UNICODE_NULL))
655
656 /* Are loud operations enabled? */
658 {
659 /* If so, the operation will be loud only if filename ends with all.scr */
663 {
665 }
666 }
667#undef ALLSCR_LENGTH
668}
#define ALLSCR_LENGTH
Referenced by RxCommonRead(), and RxCommonWrite().
◆ DECLARE_CONST_UNICODE_STRING()
| DECLARE_CONST_UNICODE_STRING | ( | unknownId | , |
| L"???" | |||
| ) |
◆ RxAcquireFileForNtCreateSection()
| VOID NTAPI RxAcquireFileForNtCreateSection | ( | PFILE_OBJECT | FileObject | ) |
Definition at line 276 of file rxce.c.
Referenced by RxInitializeDispatchVectors().
◆ RxAcquireForCcFlush()
| NTSTATUS NTAPI RxAcquireForCcFlush | ( | PFILE_OBJECT | FileObject, |
| PDEVICE_OBJECT | DeviceObject | ||
| ) |
Definition at line 284 of file rxce.c.
Referenced by RxInitializeDispatchVectors().
◆ RxAddToTopLevelIrpAllocatedContextsList()
| VOID RxAddToTopLevelIrpAllocatedContextsList | ( | PRX_TOPLEVELIRP_CONTEXT | TopLevelContext | ) |
Definition at line 752 of file rdbss.c.
754{
756
758
761
765}
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778
Referenced by __RxInitializeTopLevelIrpContext().
◆ RxAddToWorkque()
Definition at line 772 of file rdbss.c.
775{
776 ULONG Queued;
779
780 RxCaptureParamBlock;
781
782 RxContext->PostRequest = FALSE;
783
784 /* First of all, select the appropriate queue - delayed for prefix claim, critical for the rest */
787 {
790 }
791 else
792 {
795 }
796
797 /* Check for overflow */
799 {
801
803 /* In case of an overflow, add the new queued call to the overflow list */
804 if (Queued > 1)
805 {
809
811 return;
812 }
813
815 }
816
819}
@ RX_CONTEXT_FLAG_FSP_DELAYED_OVERFLOW_QUEUE
Definition: rxcontx.h:296
@ RX_CONTEXT_FLAG_FSP_CRITICAL_OVERFLOW_QUEUE
Definition: rxcontx.h:297
LONG OverflowQueueCount[RxMaximumWorkQueue]
Definition: rxstruc.h:120
LIST_ENTRY OverflowQueue[RxMaximumWorkQueue]
Definition: rxstruc.h:121
RX_SPIN_LOCK OverflowQueueSpinLock
Definition: rxstruc.h:122
volatile LONG PostedRequestCount[RxMaximumWorkQueue]
Definition: rxstruc.h:119
Definition: extypes.h:202
VOID NTAPI ExQueueWorkItem(IN PWORK_QUEUE_ITEM WorkItem, IN WORK_QUEUE_TYPE QueueType)
Definition: work.c:723
enum _WORK_QUEUE_TYPE WORK_QUEUE_TYPE
Referenced by RxCommonWrite(), and RxFsdPostRequest().
◆ RxAdjustFileTimesAndSize()
| VOID RxAdjustFileTimesAndSize | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 825 of file rdbss.c.
827{
829 LARGE_INTEGER CurrentTime;
830 FILE_BASIC_INFORMATION FileBasicInfo;
831 FILE_END_OF_FILE_INFORMATION FileEOFInfo;
832 BOOLEAN FileModified, SetLastChange, SetLastAccess, SetLastWrite, NeedUpdate;
833
834 RxCaptureFcb;
835 RxCaptureFobx;
836 RxCaptureParamBlock;
837 RxCaptureFileObject;
838
839 PAGED_CODE();
840
841 /* If Cc isn't initialized, the file was not read nor written, nothing to do */
843 {
844 return;
845 }
846
847 /* Get now */
848 KeQuerySystemTime(&CurrentTime);
849
850 /* Was the file modified? */
852 /* We'll set last write if it was modified and user didn't update yet */
854 /* File was accessed if: written or read (fastio), we'll update last access if user didn't */
855 SetLastAccess = SetLastWrite ||
858 /* We'll set last change if it was modified and user didn't update yet */
860
861 /* Nothing to update? Job done */
862 if (!FileModified && !SetLastWrite && !SetLastAccess && !SetLastChange)
863 {
864 return;
865 }
866
867 /* By default, we won't issue any MRxSetFileInfoAtCleanup call */
868 NeedUpdate = FALSE;
870
871 /* Update lastwrite time if required */
872 if (SetLastWrite)
873 {
874 NeedUpdate = TRUE;
877 }
878
879 /* Update lastaccess time if required */
880 if (SetLastAccess)
881 {
882 NeedUpdate = TRUE;
885 }
886
887 /* Update lastchange time if required */
888 if (SetLastChange)
889 {
890 NeedUpdate = TRUE;
893 }
894
895 /* If one of the date was modified, issue a call to mini-rdr */
896 if (NeedUpdate)
897 {
899 RxContext->Info.Buffer = &FileBasicInfo;
901
904 }
905
906 /* If the file was modified, update its EOF */
907 if (FileModified)
908 {
910
912 RxContext->Info.Buffer = &FileEOFInfo;
914
917 }
918}
Definition: nsiface.idl:2307
Definition: nt_native.h:938
Definition: nt_native.h:976
struct _RX_CONTEXT::@2146::@2154 Info
Definition: typedefs.h:103
Referenced by RxCommonCleanup().
◆ RxAllocateCanonicalNameBuffer()
| NTSTATUS RxAllocateCanonicalNameBuffer | ( | PRX_CONTEXT | RxContext, |
| PUNICODE_STRING | CanonicalName, | ||
| USHORT | CanonicalLength | ||
| ) |
Definition at line 924 of file rdbss.c.
928{
929 PAGED_CODE();
930
931 DPRINT("RxContext: %p - CanonicalNameBuffer: %p\n", RxContext, RxContext->Create.CanonicalNameBuffer);
932
933 /* Context must be free of any already allocated name */
935
936 /* Validate string length */
938 {
941 }
942
943 CanonicalName->Buffer = RxAllocatePoolWithTag(PagedPool | POOL_COLD_ALLOCATION, CanonicalLength, RX_MISC_POOLTAG);
945 {
947 }
948
949 CanonicalName->Length = 0;
950 CanonicalName->MaximumLength = CanonicalLength;
951
952 /* Set the two places - they must always be identical */
955
957}
struct _RX_CONTEXT::@2148::@2160 Create
#define POOL_COLD_ALLOCATION
Referenced by RxFirstCanonicalize().
◆ RxAssert()
Definition at line 645 of file rxce.c.
650{
653
654 /* If we're not asked to continue, just stop the system */
656 {
658 }
659
660 /* Otherwise, capture context to offer the user to dump it */
662
663 /* Loop until the user hits 'i' */
665 {
666 /* If no file provided, use empty name */
668 {
670 }
671
672 /* If no message provided, use empty one */
674 {
676 }
677
678 /* Display the message */
679 DbgPrint("\n*** Assertion failed: %s%s\n*** Source File: %s, line %ld\n\n", Message, Assert, File, Line);
680 /* And ask the user */
682 /* If he asks for ignore, quit
683 * In case of invalid input, ask again
684 */
686 {
688 {
689 return;
690 }
691
692 continue;
693 }
694
695 /* Break: offer the user to dump the context and break */
697 DbgBreakPoint();
698
699 /* Continue looping, so that after dump, execution can continue (with ignore) */
700 }
701}
NTSYSAPI void WINAPI DbgBreakPoint(void)
NTSYSAPI ULONG NTAPI DbgPrompt(_In_z_ PCCH Prompt, _Out_writes_bytes_(MaximumResponseLength) PCH Response, _In_ ULONG MaximumResponseLength)
NTSYSAPI VOID NTAPI RtlCaptureContext(_Out_ PCONTEXT ContextRecord)
VOID NTAPI KeBugCheckEx(_In_ ULONG BugCheckCode, _In_ ULONG_PTR BugCheckParameter1, _In_ ULONG_PTR BugCheckParameter2, _In_ ULONG_PTR BugCheckParameter3, _In_ ULONG_PTR BugCheckParameter4)
Definition: rtlcompat.c:108
Definition: ncftp.h:79
Definition: ncftp.h:89
Definition: nt_native.h:1406
◆ RxCancelNotifyChangeDirectoryRequestsForFobx()
Definition at line 963 of file rdbss.c.
965{
969 LIST_ENTRY ContextsToCancel;
970
971 /* Init a list for the contexts to cancel */
972 InitializeListHead(&ContextsToCancel);
973
974 /* Lock our list lock */
976
977 /* Now, browse all the active contexts, to find the associated ones */
980 {
983
984 /* Not the IRP we're looking for, ignore */
987 {
988 continue;
989 }
990
991 /* Not the FOBX we're looking for, ignore */
993 {
994 continue;
995 }
996
997 /* No cancel routine (can't be cancel, then), ignore */
999 {
1000 continue;
1001 }
1002
1003 /* Mark our context as cancelled */
1005
1006 /* Move it to our list */
1009
1011 }
1012
1013 /* Done with the contexts */
1015
1016 /* Now, handle all our "extracted" contexts */
1018 {
1021
1022 /* If they had an associated IRP (should be always true) */
1024 {
1025 /* Then, call cancel routine */
1029 }
1030
1031 /* And delete the context */
1033 }
1034}
#define RxDereferenceAndDeleteRxContext(RXCONTEXT)
Definition: rxcontx.h:514
Definition: typedefs.h:120
Definition: rxcontx.h:100
Referenced by RxCommonCleanup().
◆ RxCancelNotifyChangeDirectoryRequestsForVNetRoot()
| NTSTATUS RxCancelNotifyChangeDirectoryRequestsForVNetRoot | ( | PV_NET_ROOT | VNetRoot, |
| BOOLEAN | ForceFilesClosed | ||
| ) |
Definition at line 1040 of file rdbss.c.
1043{
1048 LIST_ENTRY ContextsToCancel;
1049
1050 /* Init a list for the contexts to cancel */
1051 InitializeListHead(&ContextsToCancel);
1052
1053 /* Lock our list lock */
1055
1056 /* Assume success */
1058
1059 /* Now, browse all the active contexts, to find the associated ones */
1062 {
1065
1066 /* Not the IRP we're looking for, ignore */
1069 {
1070 continue;
1071 }
1072
1073 /* Not the VNetRoot we're looking for, ignore */
1076 {
1077 continue;
1078 }
1079
1080 /* No cancel routine (can't be cancel, then), ignore */
1082 {
1083 continue;
1084 }
1085
1086 /* At that point, we found a matching context
1087 * If we're not asked to force close, then fail - it's still open
1088 */
1089 if (!ForceFilesClosed)
1090 {
1092 break;
1093 }
1094
1095 /* Mark our context as cancelled */
1097
1098 /* Move it to our list */
1101
1103 }
1104
1105 /* Done with the contexts */
1107
1109 {
1111 }
1112
1113 /* Now, handle all our "extracted" contexts */
1115 {
1118
1119 /* If they had an associated IRP (should be always true) */
1121 {
1122 /* Then, call cancel routine */
1126 }
1127
1128 /* And delete the context */
1130 }
1131
1133}
Definition: fcb.h:58
Referenced by RxFinalizeConnection().
◆ RxCancelOperationInOverflowQueue()
| BOOLEAN RxCancelOperationInOverflowQueue | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 1139 of file rdbss.c.
1141{
1143 BOOLEAN OperationToCancel;
1144
1145 /* By default, nothing cancelled */
1146 OperationToCancel = FALSE;
1147
1148 /* Acquire the overflow spinlock */
1150
1151 /* Is our context in any queue? */
1152 if (BooleanFlagOn(RxContext->Flags, (RX_CONTEXT_FLAG_FSP_DELAYED_OVERFLOW_QUEUE | RX_CONTEXT_FLAG_FSP_CRITICAL_OVERFLOW_QUEUE)))
1153 {
1154 /* Make sure flag is consistent with facts... */
1156 {
1157 /* Remove it from the list */
1160
1161 /* Decrement appropriate count */
1163 {
1165 }
1166 else
1167 {
1169 }
1170
1171 /* Clear the flag */
1172 ClearFlag(RxContext->Flags, ~(RX_CONTEXT_FLAG_FSP_DELAYED_OVERFLOW_QUEUE | RX_CONTEXT_FLAG_FSP_CRITICAL_OVERFLOW_QUEUE));
1173
1174 /* Time to cancel! */
1175 OperationToCancel = TRUE;
1176 }
1177 }
1178
1180
1181 /* We have something to cancel & complete */
1182 if (OperationToCancel)
1183 {
1184 RxRemoveOperationFromBlockingQueue(RxContext);
1186 }
1187
1188 return OperationToCancel;
1189}
VOID RxRemoveOperationFromBlockingQueue(_Inout_ PRX_CONTEXT RxContext)
NTSTATUS RxCompleteRequest(_In_ PRX_CONTEXT pContext, _In_ NTSTATUS Status)
Referenced by RxpCancelRoutine().
◆ RxCancelRoutine()
| VOID NTAPI RxCancelRoutine | ( | PDEVICE_OBJECT | DeviceObject, |
| PIRP | Irp | ||
| ) |
Definition at line 1196 of file rdbss.c.
1199{
1202 PRX_CONTEXT RxContext;
1203
1204 /* Lock our contexts list */
1206
1207 /* Now, find a context that matches the cancelled IRP */
1210 {
1213
1214 /* Found! */
1216 {
1217 break;
1218 }
1219 }
1220
1221 /* If we reached the end of the list, we didn't find any context, so zero the buffer
1222 * If the context is already under cancellation, forget about it too
1223 */
1225 {
1226 RxContext = NULL;
1227 }
1228 else
1229 {
1230 /* Otherwise, reference it and mark it cancelled */
1233 }
1234
1235 /* Done with the contexts list */
1237
1238 /* And done with the cancellation, we'll do it now */
1240
1241 /* If we have a context to cancel */
1243 {
1244 /* We cannot executed at dispatch, so queue a deferred cancel */
1246 {
1247 RxDispatchToWorkerThread(RxFileSystemDeviceObject, CriticalWorkQueue, RxpCancelRoutine, RxContext);
1248 }
1249 /* Cancel now! */
1250 else
1251 {
1252 RxpCancelRoutine(RxContext);
1253 }
1254 }
1255}
NTSTATUS NTAPI RxDispatchToWorkerThread(_In_ PRDBSS_DEVICE_OBJECT pMRxDeviceObject, _In_ WORK_QUEUE_TYPE WorkQueueType, _In_ PRX_WORKERTHREAD_ROUTINE Routine, _In_ PVOID pContext)
Referenced by RxFsdCommonDispatch().
◆ RxCanonicalizeFileNameByServerSpecs()
| NTSTATUS RxCanonicalizeFileNameByServerSpecs | ( | PRX_CONTEXT | RxContext, |
| PUNICODE_STRING | NetRootName | ||
| ) |
Definition at line 1261 of file rdbss.c.
1264{
1265 USHORT NextChar, CurChar;
1266 USHORT MaxChars;
1267
1268 PAGED_CODE();
1269
1270 /* Validate file name is not empty */
1272 if (MaxChars == 0)
1273 {
1275 }
1276
1277 /* Validate name is correct */
1278 for (NextChar = 0, CurChar = 0; CurChar + 1 < MaxChars; NextChar = CurChar + 1)
1279 {
1281
1283 {
1285 {
1286 break;
1287 }
1288 }
1289
1290 CurChar = i - 1;
1291 if (CurChar == NextChar)
1292 {
1293 if (((NetRootName->Buffer[NextChar] != '\\' && NetRootName->Buffer[NextChar] != ':') || NextChar == (MaxChars - 1)) && NetRootName->Buffer[NextChar] != '.')
1294 {
1295 continue;
1296 }
1297
1298 if (CurChar != 0)
1299 {
1300 if (CurChar >= MaxChars - 1)
1301 {
1302 continue;
1303 }
1304
1306 {
1308 }
1309 }
1310 else
1311 {
1313 {
1315 }
1316 }
1317 }
1318 else
1319 {
1320 if ((CurChar - NextChar) == 1)
1321 {
1323 {
1324 continue;
1325 }
1326
1327 if (NetRootName->Buffer[NextChar] == '\\' || NetRootName->Buffer[NextChar] == ':' || NetRootName->Buffer[NextChar] == '.')
1328 {
1330 }
1331 }
1332 else
1333 {
1334 if ((CurChar - NextChar) != 2 || (NetRootName->Buffer[NextChar] != '\\' && NetRootName->Buffer[NextChar] != ':')
1336 {
1337 continue;
1338 }
1339
1341 {
1343 }
1344 }
1345 }
1346 }
1347
1349}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
Referenced by RxCanonicalizeNameAndObtainNetRoot().
◆ RxCanonicalizeNameAndObtainNetRoot()
| NTSTATUS RxCanonicalizeNameAndObtainNetRoot | ( | PRX_CONTEXT | RxContext, |
| PUNICODE_STRING | FileName, | ||
| PUNICODE_STRING | NetRootName | ||
| ) |
Definition at line 1352 of file rdbss.c.
1356{
1358 NET_ROOT_TYPE NetRootType;
1359 UNICODE_STRING CanonicalName;
1360
1361 RxCaptureParamBlock;
1362 RxCaptureFileObject;
1363
1364 PAGED_CODE();
1365
1366 NetRootType = NET_ROOT_WILD;
1367
1368 RtlInitEmptyUnicodeString(NetRootName, NULL, 0);
1369 RtlInitEmptyUnicodeString(&CanonicalName, NULL, 0);
1370
1371 /* if not relative opening, just handle the passed name */
1373 {
1376 {
1378 }
1379 }
1380 else
1381 {
1383
1384 /* Make sure we have a valid FCB and a FOBX */
1387 {
1389 }
1390
1392 {
1394 }
1395
1396 UNIMPLEMENTED;
1397 }
1398
1399 /* Get/Create the associated VNetRoot for opening */
1403 {
1405
1406 RxFreeCanonicalNameBuffer(RxContext);
1409 {
1411 }
1412 }
1413
1414 /* Filename cannot contain wildcards */
1416 {
1418 }
1419
1420 /* Make sure file name is correct */
1422 {
1424 }
1425
1426 /* Give the mini-redirector a chance to prepare the name */
1428 {
1430 {
1431 NTSTATUS IgnoredStatus;
1432
1433 MINIRDR_CALL(IgnoredStatus, RxContext, RxContext->Create.pNetRoot->pSrvCall->RxDeviceObject->Dispatch,
1434 MRxPreparseName, (RxContext, NetRootName));
1435 (void)IgnoredStatus;
1436 }
1437 }
1438
1440}
BOOLEAN NTAPI FsRtlDoesNameContainWildCards(IN PUNICODE_STRING Name)
Definition: name.c:464
VOID RxFreeCanonicalNameBuffer(PRX_CONTEXT Context)
Definition: rdbss.c:6159
NTSTATUS RxCanonicalizeFileNameByServerSpecs(PRX_CONTEXT RxContext, PUNICODE_STRING NetRootName)
Definition: rdbss.c:1261
NTSTATUS RxFirstCanonicalize(PRX_CONTEXT RxContext, PUNICODE_STRING FileName, PUNICODE_STRING CanonicalName, PNET_ROOT_TYPE NetRootType)
Definition: rdbss.c:6010
NTSTATUS RxFindOrConstructVirtualNetRoot(_In_ PRX_CONTEXT RxContext, _In_ PUNICODE_STRING CanonicalName, _In_ NET_ROOT_TYPE NetRootType, _In_ PUNICODE_STRING RemainingName)
Definition: cdstruc.h:902
Definition: filecomp.c:348
Definition: env_spec_w32.h:368
Referenced by RxCommonCreate().
◆ RxCheckFcbStructuresForAlignment()
Definition at line 1447 of file rdbss.c.
Referenced by RxDriverEntry().
◆ RxCheckShareAccessPerSrvOpens()
| NTSTATUS RxCheckShareAccessPerSrvOpens | ( | IN PFCB | Fcb, |
| IN ACCESS_MASK | DesiredAccess, | ||
| IN ULONG | DesiredShareAccess | ||
| ) |
Definition at line 1477 of file rdbss.c.
1481{
1484 BOOLEAN DeleteAccess;
1486
1487 PAGED_CODE();
1488
1490
1491 RxDumpWantedAccess("RxCheckShareAccessPerSrvOpens", "", "RxCheckShareAccessPerSrvOpens", DesiredAccess, DesiredShareAccess);
1492 RxDumpCurrentAccess("RxCheckShareAccessPerSrvOpens", "", "RxCheckShareAccessPerSrvOpens", ShareAccess);
1493
1494 /* Check if any access wanted */
1498
1500 {
1504
1505 /* Check whether there's a violation */
1508 (WriteAccess &&
1510 (DeleteAccess &&
1512 ((ShareAccess->Readers != 0) && !SharedRead) ||
1513 ((ShareAccess->Writers != 0) && !SharedWrite) ||
1514 ((ShareAccess->Deleters != 0) && !SharedDelete))
1515 {
1517 }
1518 }
1519
1521}
_In_ PIO_STACK_LOCATION _Inout_ PFILE_OBJECT _Inout_ PVCB _Outptr_result_maybenull_ PDCB _In_ PDCB _In_ PDIRENT _In_ ULONG _In_ ULONG _In_ PUNICODE_STRING _In_ PACCESS_MASK _In_ USHORT ShareAccess
Definition: create.c:4147
Definition: iotypes.h:524
_Must_inspect_result_ _In_ WDFDEVICE _In_ ULONG _In_ ACCESS_MASK DesiredAccess
Definition: wdfdevice.h:2658
Referenced by RxSearchForCollapsibleOpen().
◆ RxCleanupPipeQueues()
| VOID RxCleanupPipeQueues | ( | PRX_CONTEXT | Context | ) |
Definition at line 1524 of file rdbss.c.
Referenced by RxCommonCleanup().
◆ RxCloseAssociatedSrvOpen()
| NTSTATUS RxCloseAssociatedSrvOpen | ( | IN PFOBX | Fobx, |
| IN PRX_CONTEXT RxContext | OPTIONAL | ||
| ) |
Definition at line 1534 of file rdbss.c.
1537{
1540 PSRV_OPEN SrvOpen;
1541 BOOLEAN CloseSrvOpen;
1542 PRX_CONTEXT LocalContext;
1543
1544 PAGED_CODE();
1545
1546 /* Assume SRV_OPEN is already closed */
1547 CloseSrvOpen = FALSE;
1548 /* If we have a FOBX, we'll have to close it */
1550 {
1551 /* If the FOBX isn't closed yet */
1553 {
1554 SrvOpen = Fobx->SrvOpen;
1556 /* Check whether we've to close SRV_OPEN first */
1558 {
1559 CloseSrvOpen = TRUE;
1560 }
1561 else
1562 {
1564
1565 /* Not much to do */
1567
1568 if (SrvOpen->OpenCount > 0)
1569 {
1570 --SrvOpen->OpenCount;
1571 }
1572 }
1573 }
1574
1575 /* No need to close SRV_OPEN, so close FOBX */
1576 if (!CloseSrvOpen)
1577 {
1578 RxMarkFobxOnClose(Fobx);
1579
1581 }
1582 }
1583 else
1584 {
1585 /* No FOBX? No RX_CONTEXT, ok, job done! */
1587 {
1589 }
1590
1591 /* Get the FCB from RX_CONTEXT */
1593 SrvOpen = NULL;
1594 }
1595
1596 /* If we don't have RX_CONTEXT, allocte one, we'll need it */
1598 {
1600
1601 LocalContext = RxCreateRxContext(NULL, Fcb->RxDeviceObject, RX_CONTEXT_FLAG_MUST_SUCCEED_NONBLOCKING | RX_CONTEXT_FLAG_WAIT);
1603 {
1605 }
1606
1607 LocalContext->MajorFunction = 2;
1611 }
1612 else
1613 {
1614 LocalContext = RxContext;
1615 }
1616
1618
1619 /* Now, close the FOBX */
1621 {
1622 RxMarkFobxOnClose(Fobx);
1623 }
1624 else
1625 {
1627 }
1628
1629 /* If not a "standard" file, SRV_OPEN can be null */
1631 {
1632 ASSERT((NodeType(Fcb) == RDBSS_NTC_OPENTARGETDIR_FCB) || (NodeType(Fcb) == RDBSS_NTC_IPC_SHARE) || (NodeType(Fcb) == RDBSS_NTC_MAILSLOT));
1634
1635 if (LocalContext != RxContext)
1636 {
1637 RxDereferenceAndDeleteRxContext(LocalContext);
1638 }
1639
1641 }
1642
1643 /* If SRV_OPEN isn't in a good condition, nothing to close */
1645 {
1646 if (LocalContext != RxContext)
1647 {
1648 RxDereferenceAndDeleteRxContext(LocalContext);
1649 }
1650
1652 }
1653
1654 /* Decrease open count */
1655 if (SrvOpen->OpenCount > 0)
1656 {
1657 --SrvOpen->OpenCount;
1658 }
1659
1660 /* If we're the only one left, is there a FOBX handled by Scavenger? */
1661 if (SrvOpen->OpenCount == 1)
1662 {
1664 {
1665 if (!IsListEmpty(&CONTAINING_RECORD(SrvOpen->FobxList.Flink, FOBX, FobxQLinks)->ScavengerFinalizationList))
1666 {
1668 }
1669 }
1670 }
1671
1672 /* Nothing left, purge FCB */
1674 {
1676 }
1677
1678 /* Already closed? Job done! */
1679 SrvOpen = Fobx->SrvOpen;
1681 (SrvOpen->OpenCount != 0 && !BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_PENDING)) ||
1683 {
1685 if (LocalContext != RxContext)
1686 {
1687 RxDereferenceAndDeleteRxContext(LocalContext);
1688 }
1689
1691 }
1692
1694
1695 /* Inform mini-rdr about closing */
1697 DPRINT("MRxCloseSrvOpen returned: %lx, called with RX_CONTEXT %p for FOBX %p (FCB %p, SRV_OPEN %p)\n ",
1699
1700 /* And mark as such */
1702 SrvOpen->Key = (PVOID)-1;
1703
1704 /* If we were delayed, we're not! */
1706 {
1708 }
1709
1710 /* Clear access */
1711 RxRemoveShareAccessPerSrvOpens(SrvOpen);
1712 RxPurgeChangeBufferingStateRequestsForSrvOpen(SrvOpen);
1713
1714 /* Dereference */
1716
1717 /* Mark the FOBX closed as well */
1719
1720 if (LocalContext != RxContext)
1721 {
1722 RxDereferenceAndDeleteRxContext(LocalContext);
1723 }
1724
1726}
VOID RxPurgeChangeBufferingStateRequestsForSrvOpen(_In_ PSRV_OPEN SrvOpen)
struct _MRX_SRV_OPEN_ * PMRX_SRV_OPEN
struct _MRX_FOBX_ * PMRX_FOBX
#define SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_PENDING
Definition: mrxfcb.h:136
VOID RxRemoveShareAccessPerSrvOpens(IN OUT PSRV_OPEN SrvOpen)
Definition: rdbss.c:8635
@ RX_CONTEXT_FLAG_MUST_SUCCEED_NONBLOCKING
Definition: rxcontx.h:309
PRX_CONTEXT NTAPI RxCreateRxContext(_In_ PIRP Irp, _In_ PRDBSS_DEVICE_OBJECT RxDeviceObject, _In_ ULONG InitialContextFlags)
VOID RxMarkFobxOnClose(_In_ PFOBX Fobx)
Referenced by RxCommonClose().
◆ RxCollapseOrCreateSrvOpen()
| NTSTATUS RxCollapseOrCreateSrvOpen | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 1732 of file rdbss.c.
1734{
1737 PSRV_OPEN SrvOpen;
1740 RX_BLOCK_CONDITION FcbCondition;
1741
1742 RxCaptureFcb;
1743 RxCaptureParamBlock;
1744
1745 PAGED_CODE();
1746
1748
1750 ++capFcb->UncleanCount;
1751
1754
1756
1757 /* Try to find a reusable SRV_OPEN */
1760 {
1761 /* If none found, create one */
1764 {
1766 }
1767 else
1768 {
1769 SrvOpen->DesiredAccess = DesiredAccess;
1770 SrvOpen->ShareAccess = ShareAccess;
1772 }
1773
1775
1777 {
1778 FcbCondition = Condition_Bad;
1779 }
1780 else
1781 {
1782 RxInitiateSrvOpenKeyAssociation(SrvOpen);
1783
1784 /* Cookie to check the mini-rdr doesn't mess with RX_CONTEXT */
1786 /* Inform the mini-rdr we're handling a create */
1789
1792 {
1793 /* In case of overwrite, reset file size */
1795 {
1800 RxContext->CurrentIrpSp->FileObject->SectionObjectPointer = &capFcb->NonPaged->SectionObjectPointers;
1801 CcSetFileSizes(RxContext->CurrentIrpSp->FileObject, (PCC_FILE_SIZES)&capFcb->Header.AllocationSize);
1803 }
1804 else
1805 {
1806 /* Otherwise, adjust sizes */
1807 RxContext->CurrentIrpSp->FileObject->SectionObjectPointer = &capFcb->NonPaged->SectionObjectPointers;
1809 {
1811 }
1812 CcSetFileSizes(RxContext->CurrentIrpSp->FileObject, (PCC_FILE_SIZES)&capFcb->Header.AllocationSize);
1813 }
1814 }
1815
1816 /* Set the IoStatus with information returned by mini-rdr */
1818
1820 /* Set SRV_OPEN state - good or bad - depending on whether create succeed */
1822
1824
1825 RxCompleteSrvOpenKeyAssociation(SrvOpen);
1826
1828 {
1830 {
1832 }
1833 SrvOpen->CreateOptions = RxContext->Create.NtCreateParameters.CreateOptions;
1834 FcbCondition = Condition_Good;
1835 }
1836 else
1837 {
1838 FcbCondition = Condition_Bad;
1841
1843 {
1846 }
1847 }
1848 }
1849
1850 /* Set FCB state - good or bad - depending on whether create succeed */
1853 }
1855 {
1856 BOOLEAN IsGood, ExtraOpen;
1857
1858 /* A reusable SRV_OPEN was found */
1860 ExtraOpen = FALSE;
1861
1863
1865 /* If the SRV_OPEN isn't in a stable situation, wait for it to become stable */
1867 {
1868 RxReferenceSrvOpen(SrvOpen);
1869 ++SrvOpen->OpenCount;
1870 ExtraOpen = TRUE;
1871
1874
1875 RxWaitForStableSrvOpen(SrvOpen, RxContext);
1876
1878 {
1880 }
1881
1883 }
1884
1885 /* Inform the mini-rdr we do an opening with a reused SRV_OPEN */
1886 if (IsGood)
1887 {
1889
1891 }
1892 else
1893 {
1895 }
1896
1897 if (ExtraOpen)
1898 {
1899 --SrvOpen->OpenCount;
1901 }
1902 }
1903
1904 --capFcb->UncleanCount;
1905
1908}
VOID RxCompleteSrvOpenKeyAssociation(_Inout_ PSRV_OPEN SrvOpen)
VOID RxInitiateSrvOpenKeyAssociation(_Inout_ PSRV_OPEN SrvOpen)
#define CcIsFileCached(FO)
PSRV_OPEN RxCreateSrvOpen(_In_ PV_NET_ROOT VNetRoot, _In_ OUT PFCB Fcb)
struct _SRV_OPEN * PSRV_OPEN
VOID NTAPI CcSetFileSizes(IN PFILE_OBJECT FileObject, IN PCC_FILE_SIZES FileSizes)
Definition: fssup.c:356
enum _RX_BLOCK_CONDITION RX_BLOCK_CONDITION
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:56
NTSTATUS RxSearchForCollapsibleOpen(PRX_CONTEXT RxContext, ACCESS_MASK DesiredAccess, ULONG ShareAccess)
Definition: rdbss.c:8679
Definition: cctypes.h:14
Referenced by RxCreateFromNetRoot().
◆ RxCommonCleanup()
| NTSTATUS NTAPI RxCommonCleanup | ( | PRX_CONTEXT | Context | ) |
Definition at line 1915 of file rdbss.c.
1917{
1918#define BugCheckFileId RDBSS_BUG_CHECK_CLEANUP
1920 PFOBX Fobx;
1923 PNET_ROOT NetRoot;
1925 LARGE_INTEGER TruncateSize;
1926 PLARGE_INTEGER TruncateSizePtr;
1927 BOOLEAN NeedPurge, FcbTableAcquired, OneLeft, IsFile, FcbAcquired, LeftForDelete;
1928
1929 PAGED_CODE();
1930
1934
1935 /* File system closing, it's OK */
1937 {
1939 {
1941 }
1942
1944 }
1945
1946 /* Check we have a correct FCB type */
1951 {
1954 }
1955
1958
1959 RxMarkFobxOnCleanup(Fobx, &NeedPurge);
1960
1963 {
1965 }
1966
1967 FcbAcquired = TRUE;
1968
1969 Fobx->AssociatedFileObject = NULL;
1970
1971 /* In case it was already orphaned */
1973 {
1976
1978 {
1979 --Fcb->UncachedUncleanCount;
1980 }
1981
1982 /* Inform mini-rdr */
1984
1986 --Fobx->SrvOpen->UncleanFobxCount;
1987
1989
1991
1993 }
1994
1995 /* Report the fact that file could be set as delete on close */
1997 {
1999 }
2000
2001 /* Cancel any pending notification */
2002 RxCancelNotifyChangeDirectoryRequestsForFobx(Fobx);
2003
2004 /* Backup open count before we start playing with it */
2006
2008 FcbTableAcquired = FALSE;
2009 LeftForDelete = FALSE;
2011
2012 _SEH2_TRY
2013 {
2014 /* Unclean count and delete on close? Verify whether we're the one */
2016 {
2018 {
2019 FcbTableAcquired = TRUE;
2020 }
2021 else
2022 {
2024
2026
2029 {
2032 }
2033
2034 FcbTableAcquired = TRUE;
2035 }
2036
2037 /* That means we'll perform the delete on close! */
2039 {
2040 LeftForDelete = TRUE;
2041 }
2042 else
2043 {
2045 FcbTableAcquired = FALSE;
2046 }
2047 }
2048
2049 IsFile = FALSE;
2050 TruncateSizePtr = NULL;
2051 /* Handle cleanup for pipes and printers */
2053 {
2055 }
2056 /* Handle cleanup for files */
2058 {
2061 {
2062 /* First, unlock */
2063 FsRtlFastUnlockAll(&Fcb->Specific.Fcb.FileLock, FileObject, RxGetRequestorProcess(Context), Context);
2064
2065 /* If there are still locks to release, proceed */
2067 {
2069 Context->LowIoContext.ParamsFor.Locks.Flags = 0;
2071 }
2072
2073 /* Fix times and size */
2075
2076 /* If we're the only one left... */
2077 if (OneLeft)
2078 {
2079 /* And if we're supposed to delete on close */
2080 if (LeftForDelete)
2081 {
2082 /* Update the sizes */
2087 }
2088 /* Otherwise, call the mini-rdr to adjust sizes */
2089 else
2090 {
2091 /* File got grown up, fill with zeroes */
2094 {
2097 }
2098
2099 /* File was truncated, let mini-rdr proceed */
2101 {
2104
2105 /* Keep track of file change for Cc uninit */
2107 TruncateSizePtr = &TruncateSize;
2108 }
2109 }
2110 }
2111
2112 /* If RxMarkFobxOnCleanup() asked for purge, make sure we're the only one left first */
2113 if (NeedPurge)
2114 {
2115 if (!OneLeft)
2116 {
2117 NeedPurge = FALSE;
2118 }
2119 }
2120 /* Otherwise, try to see whether we can purge */
2121 else
2122 {
2123 NeedPurge = (OneLeft && (LeftForDelete || !BooleanFlagOn(Fcb->FcbState, FCB_STATE_COLLAPSING_ENABLED)));
2124 }
2125
2126 IsFile = TRUE;
2127 }
2128 }
2129
2130 /* We have to still be there! */
2133
2135 {
2136 --Fcb->UncachedUncleanCount;
2137 }
2138
2139 /* Inform mini-rdr about ongoing cleanup */
2141
2143 --Fobx->SrvOpen->UncleanFobxCount;
2144
2145 /* Flush cache */
2147 {
2148 /* Only if we're the last standing */
2151 {
2154 }
2155 }
2156 else
2157 {
2158 /* Always */
2160 {
2163 }
2164 }
2165
2166 /* If only remaining uncached & unclean, then flush and purge */
2168 {
2170 {
2173 {
2176 }
2177 }
2178 }
2179
2180 /* If purge required, and not about to delete, flush */
2181 if (!LeftForDelete && NeedPurge)
2182 {
2185 }
2186
2187 /* If it was a file, drop cache */
2188 if (IsFile)
2189 {
2192 }
2193
2194 /* If that's the one left for deletion, or if it needs purge, flush */
2195 if (LeftForDelete || NeedPurge)
2196 {
2198 /* If that's for deletion, also remove from FCB table */
2199 if (LeftForDelete)
2200 {
2203 FcbTableAcquired = FALSE;
2204 }
2205 }
2206
2207 /* Remove any share access */
2209 {
2211 }
2212
2213 /* In case there's caching, on a file, and we were asked to drop collapsing, handle it */
2214 if (NodeType(Fcb) == RDBSS_NTC_STORAGE_TYPE_FILE && BooleanFlagOn(Fobx->Flags, FOBX_FLAG_DISABLE_COLLAPSING) &&
2215 RxWriteCacheingAllowed(Fcb, Fobx->pSrvOpen))
2216 {
2217 NTSTATUS InternalStatus;
2218 PRX_CONTEXT InternalContext;
2219
2220 /* If we can properly set EOF, there's no need to drop collapsing, try to do it */
2221 InternalStatus = STATUS_UNSUCCESSFUL;
2226 {
2227 FILE_END_OF_FILE_INFORMATION FileEOF;
2228
2229 InternalStatus = STATUS_SUCCESS;
2230
2231 /* Initialize the context for file information set */
2234 InternalContext->pRelevantSrvOpen = Fobx->pSrvOpen;
2235
2236 /* Get EOF from the FCB */
2239 InternalContext->Info.Buffer = &FileEOF;
2241
2242 /* Call the mini-rdr */
2244
2245 /* We're done */
2246 RxDereferenceAndDeleteRxContext(InternalContext);
2247 }
2248
2249 /* We tried, so, clean the FOBX flag */
2250 ClearFlag(Fobx->Flags, FOBX_FLAG_DISABLE_COLLAPSING);
2251 /* If it failed, then, disable collapsing on the FCB */
2253 {
2255 }
2256 }
2257
2258 /* We're clean! */
2260
2261 FcbAcquired = FALSE;
2263 }
2264 _SEH2_FINALLY
2265 {
2266 if (FcbAcquired)
2267 {
2269 }
2270
2271 if (FcbTableAcquired)
2272 {
2274 }
2275 }
2276 _SEH2_END;
2277
2279#undef BugCheckFileId
2280}
NTSTATUS RxPurgeFcbInSystemCache(_In_ PFCB Fcb, _In_ PLARGE_INTEGER FileOffset OPTIONAL, _In_ ULONG Length, _In_ BOOLEAN UninitializeCacheMaps, _In_ BOOLEAN FlushFile)
NTSTATUS RxFlushFcbInSystemCache(_In_ PFCB Fcb, _In_ BOOLEAN SynchronizeWithLazyWriter)
struct _NET_ROOT * PNET_ROOT
VOID RxRemoveNameNetFcb(_Out_ PFCB ThisFcb)
NTSTATUS NTAPI FsRtlFastUnlockAll(IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PEPROCESS Process, IN PVOID Context OPTIONAL)
Definition: filelock.c:1025
VOID NTAPI RxInitializeLowIoContext(_Out_ PLOWIO_CONTEXT LowIoContext, _In_ ULONG Operation)
VOID RxUninitializeCacheMap(PRX_CONTEXT RxContext, PFILE_OBJECT FileObject, PLARGE_INTEGER TruncateSize)
Definition: rdbss.c:9414
NTSTATUS RxLowIoLockControlShell(IN PRX_CONTEXT RxContext)
Definition: rdbss.c:7212
VOID RxCancelNotifyChangeDirectoryRequestsForFobx(PFOBX Fobx)
Definition: rdbss.c:963
#define MINIRDR_CALL_THROUGH(STATUS, DISPATCH, FUNC, ARGLIST)
Definition: rxcontx.h:375
VOID RxMarkFobxOnCleanup(_In_ PFOBX pFobx, _Out_ PBOOLEAN NeedPurge)
union _FCB::@720 Specific
struct _FCB::@720::@723 Fcb
SECTION_OBJECT_POINTERS SectionObjectPointers
Definition: fatstruc.h:729
◆ RxCommonClose()
| NTSTATUS NTAPI RxCommonClose | ( | PRX_CONTEXT | Context | ) |
Definition at line 2284 of file rdbss.c.
2286{
2287#define BugCheckFileId RDBSS_BUG_CHECK_CLOSE
2289 PFOBX Fobx;
2292 BOOLEAN DereferenceFobx, AcquiredFcb;
2293
2294 PAGED_CODE();
2295
2300
2303 {
2305 }
2306
2307 AcquiredFcb = TRUE;
2308 _SEH2_TRY
2309 {
2310 BOOLEAN Freed;
2311
2312 /* Check our FCB type is expected */
2314 (NodeType(Fcb) < RDBSS_NTC_STORAGE_TYPE_DIRECTORY || (NodeType(Fcb) > RDBSS_NTC_STORAGE_TYPE_FILE &&
2316 {
2318 }
2319
2321
2322 DereferenceFobx = FALSE;
2323 /* If we're not closing FS */
2325 {
2326 PSRV_OPEN SrvOpen;
2327 PSRV_CALL SrvCall;
2328
2329 SrvOpen = (PSRV_OPEN)Fobx->pSrvOpen;
2331 /* Handle delayed close */
2333 {
2335 {
2337 {
2339
2340 if (SrvOpen->OpenCount == 1 && !BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_COLLAPSING_DISABLED))
2341 {
2342 if (InterlockedIncrement(&SrvCall->NumberOfCloseDelayedFiles) >= SrvCall->MaximumNumberOfCloseDelayedFiles)
2343 {
2345 }
2346 else
2347 {
2348 DereferenceFobx = TRUE;
2350 }
2351 }
2352 }
2353 }
2354 }
2355
2356 /* If we reach maximum of delayed close/or if there are no delayed close */
2357 if (!DereferenceFobx)
2358 {
2359 PNET_ROOT NetRoot;
2360
2363 {
2364 /* Delete if asked */
2366 {
2369
2371
2375
2378 }
2379 }
2380 }
2381
2382 RxMarkFobxOnClose(Fobx);
2383 }
2384
2385 if (DereferenceFobx)
2386 {
2389 }
2390 else
2391 {
2394 {
2396 }
2397 }
2398
2400 AcquiredFcb = !Freed;
2401
2403
2404 if (Freed)
2405 {
2407 }
2408 else
2409 {
2411 AcquiredFcb = FALSE;
2412 }
2413 }
2414 _SEH2_FINALLY
2415 {
2417 {
2418 if (AcquiredFcb)
2419 {
2421 }
2422 }
2423 else
2424 {
2425 ASSERT(!AcquiredFcb);
2426 }
2427 }
2428 _SEH2_END;
2429
2432#undef BugCheckFileId
2433}
#define RxDereferenceAndFinalizeNetFcb(Fcb, RxContext, RecursiveFinalize, ForceFinalize)
Definition: fcb.h:439
NTSTATUS RxCloseAssociatedSrvOpen(IN PFOBX Fobx, IN PRX_CONTEXT RxContext OPTIONAL)
Definition: rdbss.c:1534
VOID RxOrphanThisFcb(_In_ PFCB Fcb)
VOID RxSynchronizeWithScavenger(_In_ PRX_CONTEXT RxContext)
BOOLEAN RxScavengeRelatedFobxs(_In_ PFCB Fcb)
◆ RxCommonCreate()
| NTSTATUS NTAPI RxCommonCreate | ( | PRX_CONTEXT | Context | ) |
Definition at line 2440 of file rdbss.c.
2442{
2447
2448 PAGED_CODE();
2449
2451
2455
2456 /* Check whether that's a device opening */
2458 {
2461
2462 ++RxDeviceFCB.NodeReferenceCount;
2464
2466 DPRINT("Device opening FO: %p, DO: %p, Name: %wZ\n", FileObject, Context->RxDeviceObject, &Context->RxDeviceObject->DeviceName);
2467
2469 }
2470 else
2471 {
2473
2474 /* Make sure caller is consistent */
2475 if (FlagOn(Stack->Parameters.Create.Options, FILE_DIRECTORY_FILE | FILE_NON_DIRECTORY_FILE | FILE_OPEN_REMOTE_INSTANCE) ==
2477 {
2480 }
2481
2482 DPRINT("Ctxt: %p, FO: %p, Options: %lx, Flags: %lx, Attr: %lx, ShareAccess: %lx, DesiredAccess: %lx\n",
2483 Context, FileObject, Stack->Parameters.Create.Options, Stack->Flags, Stack->Parameters.Create.FileAttributes,
2484 Stack->Parameters.Create.ShareAccess, Stack->Parameters.Create.SecurityContext->DesiredAccess);
2486
2488 {
2489 RelatedFcb = FileObject->RelatedFileObject->FsContext;
2490 DPRINT("Rel FO: %p, path: %wZ\n", FileObject->RelatedFileObject, RelatedFcb->FcbTableEntry.Path);
2491 }
2492
2493 /* Going to rename? */
2495 {
2497 }
2498
2499 /* Copy create parameters to the context */
2501
2502 /* If the caller wants to establish a connection, go ahead */
2504 {
2506 }
2507 else
2508 {
2509 /* Validate file name */
2513 {
2516 FileObject->FileName.Length);
2517
2521 {
2523 }
2524 }
2525
2526 /* Attempt to open the file */
2527 do
2528 {
2529 UNICODE_STRING NetRootName;
2530
2531 /* Strip last \ if required */
2533 FileObject->FileName.Buffer[FileObject->FileName.Length / sizeof(WCHAR) - 1] == OBJ_NAME_PATH_SEPARATOR)
2534 {
2536 {
2538 }
2539
2542 }
2543
2545 {
2547 }
2548
2549 /* Get the associated net root to opening */
2552 {
2553 break;
2554 }
2555
2556 /* And attempt to open */
2559 {
2561
2562 /* If that happens for file creation, fail for real */
2564 {
2566 }
2567 else
2568 {
2569 /* Otherwise, if possible, attempt to scavenger current FOBX
2570 * to check whether a dormant FOBX is the reason for sharing violation
2571 */
2573 !Context->Create.ScavengingAlreadyTried)
2574 {
2575 /* Only doable with a VNetRoot */
2577 {
2578 PV_NET_ROOT VNetRoot;
2579 NT_CREATE_PARAMETERS SavedParameters;
2580
2581 /* Save create parameters */
2582 RtlCopyMemory(&SavedParameters, &Context->Create.NtCreateParameters, sizeof(NT_CREATE_PARAMETERS));
2583
2584 /* Reference the VNetRoot for the scavenging time */
2586 RxReferenceVNetRoot(VNetRoot);
2587
2588 /* Prepare the RX_CONTEXT for reuse */
2591
2592 /* Copy what we saved */
2593 RtlCopyMemory(&Context->Create.NtCreateParameters, &SavedParameters, sizeof(NT_CREATE_PARAMETERS));
2594
2595 /* And recopy what can be */
2597
2598 /* And start purging, then scavenging FOBX */
2603
2604 /* Ask for a second round */
2606
2607 /* Keep track we already scavenged */
2609
2610 /* Reference our SRV_CALL for CBS handling */
2611 RxReferenceSrvCall(VNetRoot->pNetRoot->pSrvCall);
2613
2614 /* Drop our extra reference */
2616 }
2617 }
2618 }
2619 }
2621 {
2622 Context->CurrentIrp->IoStatus.Information = 0;
2623 }
2624 else
2625 {
2627 }
2628 }
2630 }
2631
2633 {
2635 }
2637 }
2638
2641}
VOID RxpProcessChangeBufferingStateRequests(PSRV_CALL SrvCall, BOOLEAN UpdateHandlerState)
Definition: rxce.c:6417
struct _V_NET_ROOT * PV_NET_ROOT
VOID RxpPrepareCreateContextForReuse(PRX_CONTEXT RxContext)
Definition: rdbss.c:7654
NTSTATUS RxCreateFromNetRoot(PRX_CONTEXT Context, PUNICODE_STRING NetRootName)
Definition: rdbss.c:5114
NTSTATUS RxCanonicalizeNameAndObtainNetRoot(PRX_CONTEXT RxContext, PUNICODE_STRING FileName, PUNICODE_STRING NetRootName)
Definition: rdbss.c:1352
VOID NTAPI RxReinitializeContext(_Inout_ PRX_CONTEXT RxContext)
@ RX_CONTEXT_CREATE_FLAG_STRIPPED_TRAILING_BACKSLASH
Definition: rxcontx.h:325
VOID RxScavengeFobxsForNetRoot(PNET_ROOT NetRoot, PFCB PurgingFcb, BOOLEAN SynchronizeWithScavenger)
Definition: rxce.c:7798
NTSTATUS RxPurgeRelatedFobxs(PNET_ROOT NetRoot, PRX_CONTEXT RxContext, BOOLEAN AttemptFinalization, PFCB PurgingFcb)
Definition: rxce.c:7133
Definition: Bus_PDO_EvalMethod.c:93
Definition: Bus_PDO_EvalMethod.c:105
Definition: rxcontx.h:86
◆ RxCommonDevFCBCleanup()
| NTSTATUS NTAPI RxCommonDevFCBCleanup | ( | PRX_CONTEXT | Context | ) |
Definition at line 2648 of file rdbss.c.
2650{
2653
2654 PAGED_CODE();
2655
2657
2661
2662 /* Our FOBX if set, has to be a VNetRoot */
2664 {
2667 {
2669 }
2671 }
2672 else
2673 {
2675 }
2676
2678}
Definition: mrxfcb.h:109
◆ RxCommonDevFCBClose()
| NTSTATUS NTAPI RxCommonDevFCBClose | ( | PRX_CONTEXT | Context | ) |
Definition at line 2685 of file rdbss.c.
2687{
2690 PMRX_V_NET_ROOT NetRoot;
2691
2692 PAGED_CODE();
2693
2695
2700
2701 /* Our FOBX if set, has to be a VNetRoot */
2703 {
2706 {
2707 --NetRoot->NumberOfOpens;
2709 }
2710 else
2711 {
2713 }
2715 }
2716 else
2717 {
2719 }
2720
2722}
struct _MRX_V_NET_ROOT_ * PMRX_V_NET_ROOT
#define RxAcquirePrefixTableLockExclusive(T, W)
Definition: prefix.h:83
Definition: mrxfcb.h:91
◆ RxCommonDevFCBFsCtl()
| NTSTATUS NTAPI RxCommonDevFCBFsCtl | ( | PRX_CONTEXT | Context | ) |
◆ RxCommonDevFCBIoCtl()
| NTSTATUS NTAPI RxCommonDevFCBIoCtl | ( | PRX_CONTEXT | Context | ) |
Definition at line 2738 of file rdbss.c.
2740{
2742
2743 PAGED_CODE();
2744
2746
2748 {
2750 }
2751
2752 /* Is that a prefix claim from MUP? */
2754 {
2756 }
2757
2758 /* Otherwise, pass through the mini-rdr */
2761 {
2763 {
2766 }
2767 }
2768
2771}
NTSTATUS RxXXXControlFileCallthru(PRX_CONTEXT Context)
Definition: rdbss.c:9561
Referenced by RxCommonDevFCBIoCtl().
◆ RxCommonDevFCBQueryVolInfo()
| NTSTATUS NTAPI RxCommonDevFCBQueryVolInfo | ( | PRX_CONTEXT | Context | ) |
◆ RxCommonDeviceControl()
| NTSTATUS NTAPI RxCommonDeviceControl | ( | PRX_CONTEXT | Context | ) |
Definition at line 2787 of file rdbss.c.
2789{
2791
2792 PAGED_CODE();
2793
2794 /* Prefix claim is only allowed for device, not files */
2796 {
2798 }
2799
2800 /* Submit to mini-rdr */
2804 {
2806 }
2807
2809}
NTSTATUS NTAPI RxLowIoSubmit(_In_ PRX_CONTEXT RxContext, _In_ PLOWIO_COMPLETION_ROUTINE CompletionRoutine)
NTSTATUS NTAPI RxLowIoIoCtlShellCompletion(PRX_CONTEXT RxContext)
Definition: rdbss.c:7187
VOID NTAPI RxDereferenceAndDeleteRxContext_Real(_In_ PRX_CONTEXT RxContext)
◆ RxCommonDirectoryControl()
| NTSTATUS NTAPI RxCommonDirectoryControl | ( | PRX_CONTEXT | Context | ) |
Definition at line 2816 of file rdbss.c.
2818{
2820 PFOBX Fobx;
2823
2824 PAGED_CODE();
2825
2829 DPRINT("RxCommonDirectoryControl(%p) FOBX: %p, FCB: %p, Minor: %d\n", Context, Fobx, Fcb, Stack->MinorFunction);
2830
2831 /* Call the appropriate helper */
2833 {
2835 }
2837 {
2840 {
2842 }
2843 }
2844 else
2845 {
2847 }
2848
2850}
NTSTATUS RxNotifyChangeDirectory(PRX_CONTEXT RxContext)
Definition: rdbss.c:7556
◆ RxCommonDispatchProblem()
| NTSTATUS NTAPI RxCommonDispatchProblem | ( | PRX_CONTEXT | Context | ) |
◆ RxCommonFileSystemControl()
| NTSTATUS NTAPI RxCommonFileSystemControl | ( | PRX_CONTEXT | Context | ) |
Definition at line 2863 of file rdbss.c.
2865{
2869
2870 PAGED_CODE();
2871
2875
2876 DPRINT1("RxCommonFileSystemControl: %p, %p, %d, %lx\n", Context, Irp, Stack->MinorFunction, ControlCode);
2877
2878 UNIMPLEMENTED;
2880}
◆ RxCommonFlushBuffers()
| NTSTATUS NTAPI RxCommonFlushBuffers | ( | PRX_CONTEXT | Context | ) |
◆ RxCommonLockControl()
| NTSTATUS NTAPI RxCommonLockControl | ( | PRX_CONTEXT | Context | ) |
◆ RxCommonQueryEa()
| NTSTATUS NTAPI RxCommonQueryEa | ( | PRX_CONTEXT | Context | ) |
◆ RxCommonQueryInformation()
| NTSTATUS NTAPI RxCommonQueryInformation | ( | PRX_CONTEXT | Context | ) |
Definition at line 2914 of file rdbss.c.
2916{
2917#define SET_SIZE_AND_QUERY(AlreadyConsummed, Function) \
2918 Context->Info.Length = Stack->Parameters.QueryFile.Length - (AlreadyConsummed); \
2919 Status = Function(Context, Add2Ptr(Buffer, AlreadyConsummed))
2920
2923 PFOBX Fobx;
2927 FILE_INFORMATION_CLASS FileInfoClass;
2928
2929 PAGED_CODE();
2930
2934
2939
2941 FileInfoClass = Stack->Parameters.QueryFile.FileInformationClass;
2942
2944 _SEH2_TRY
2945 {
2947
2948 /* Get a writable buffer */
2951 {
2953 _SEH2_LEAVE;
2954 }
2955 /* Zero it */
2957
2958 /* Validate file type */
2960 {
2962 {
2964 _SEH2_LEAVE;
2965 }
2967 {
2969 {
2971 }
2972 else
2973 {
2975 }
2976
2977 _SEH2_LEAVE;
2978 }
2979 }
2980
2981 /* Acquire the right lock */
2983 FileInfoClass != FileNameInformation)
2984 {
2986 {
2988 }
2989 else
2990 {
2992 }
2993
2995 {
2997 _SEH2_LEAVE;
2998 }
3000 {
3001 _SEH2_LEAVE;
3002 }
3003
3005 }
3006
3007 /* Dispatch to the right helper */
3008 switch (FileInfoClass)
3009 {
3012 break;
3013
3016 break;
3017
3020 break;
3021
3024 break;
3025
3028 break;
3029
3033 {
3034 break;
3035 }
3036
3039 {
3040 break;
3041 }
3042
3046 {
3047 break;
3048 }
3049
3054 {
3055 break;
3056 }
3057
3063 {
3064 break;
3065 }
3066
3072 break;
3073
3076 break;
3077
3082 break;
3083
3086 break;
3087
3088 default:
3091 break;
3092 }
3093
3095 {
3098 }
3099
3101 }
3102 _SEH2_FINALLY
3103 {
3105 {
3107 }
3108 }
3109 _SEH2_END;
3110
3113
3114#undef SET_SIZE_AND_QUERY
3115}
NTSTATUS RxQueryInternalInfo(PRX_CONTEXT RxContext, PFILE_INTERNAL_INFORMATION InternalInfo)
Definition: rdbss.c:8274
NTSTATUS RxQueryBasicInfo(PRX_CONTEXT RxContext, PFILE_BASIC_INFORMATION BasicInfo)
Definition: rdbss.c:8026
NTSTATUS RxQueryCompressedInfo(PRX_CONTEXT RxContext, PFILE_COMPRESSION_INFORMATION CompressionInfo)
Definition: rdbss.c:8040
#define SET_SIZE_AND_QUERY(AlreadyConsummed, Function)
NTSTATUS RxQueryNameInfo(PRX_CONTEXT RxContext, PFILE_NAME_INFORMATION NameInfo)
Definition: rdbss.c:8286
NTSTATUS RxQueryStandardInfo(PRX_CONTEXT RxContext, PFILE_STANDARD_INFORMATION StandardInfo)
Definition: rdbss.c:8358
NTSTATUS RxQueryEaInfo(PRX_CONTEXT RxContext, PFILE_EA_INFORMATION EaInfo)
Definition: rdbss.c:8265
NTSTATUS RxQueryAlternateNameInfo(PRX_CONTEXT RxContext, PFILE_NAME_INFORMATION AltNameInfo)
Definition: rdbss.c:8014
NTSTATUS RxQueryPipeInfo(PRX_CONTEXT RxContext, PFILE_PIPE_INFORMATION PipeInfo)
Definition: rdbss.c:8337
NTSTATUS RxpQueryInfoMiniRdr(PRX_CONTEXT RxContext, FILE_INFORMATION_CLASS FileInfoClass, PVOID Buffer)
Definition: rdbss.c:7690
NTSTATUS RxQueryPositionInfo(PRX_CONTEXT RxContext, PFILE_POSITION_INFORMATION PositionInfo)
Definition: rdbss.c:8346
PVOID RxMapSystemBuffer(_In_ PRX_CONTEXT RxContext)
Definition: winternl.h:641
Definition: from_kernel.h:277
Definition: nt_native.h:954
Definition: propsheet.cpp:53
◆ RxCommonQueryQuotaInformation()
| NTSTATUS NTAPI RxCommonQueryQuotaInformation | ( | PRX_CONTEXT | Context | ) |
◆ RxCommonQuerySecurity()
| NTSTATUS NTAPI RxCommonQuerySecurity | ( | PRX_CONTEXT | Context | ) |
◆ RxCommonQueryVolumeInformation()
| NTSTATUS NTAPI RxCommonQueryVolumeInformation | ( | PRX_CONTEXT | Context | ) |
Definition at line 3140 of file rdbss.c.
3142{
3145 PFOBX Fobx;
3148
3149 PAGED_CODE();
3150
3153
3155
3160
3164
3165 /* Forward to mini-rdr */
3167
3168 /* Post request if mini-rdr asked to */
3170 {
3172 }
3173 else
3174 {
3176 }
3177
3180}
◆ RxCommonRead()
| NTSTATUS NTAPI RxCommonRead | ( | PRX_CONTEXT | Context | ) |
Definition at line 3184 of file rdbss.c.
3186{
3189 PFOBX Fobx;
3191 PNET_ROOT NetRoot;
3192 PVOID SystemBuffer;
3196 PLOWIO_CONTEXT LowIoContext;
3197 PRDBSS_DEVICE_OBJECT RxDeviceObject;
3199 BOOLEAN CanWait, PagingIo, NoCache, Sync, PostRequest, IsPipe, ReadCachingEnabled, ReadCachingDisabled, InFsp, OwnerSet;
3200
3201 PAGED_CODE();
3202
3204 Fobx = (PFOBX)RxContext->pFobx;
3206
3207 /* Get some parameters */
3208 Irp = RxContext->CurrentIrp;
3209 Stack = RxContext->CurrentIrpSp;
3218 (CanWait ? "CW" : "!CW"), (PagingIo ? "PI" : "!PI"), (NoCache ? "NC" : "!NC"), (Sync ? "S" : "!S"));
3219
3220 RxItsTheSameContext();
3221
3222 Irp->IoStatus.Information = 0;
3223
3224 /* Should the read be loud - so far, it's just ignored on ReactOS:
3225 * s/DPRINT/DPRINT1/g will make it loud
3226 */
3227 LowIoContext = &RxContext->LowIoContext;
3228 CheckForLoudOperations(RxContext);
3230 {
3234 }
3235
3236 RxDeviceObject = RxContext->RxDeviceObject;
3237 /* Update stats */
3238 if (!BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_IN_FSP) && Fcb->CachedNetRootType == NET_ROOT_DISK)
3239 {
3241
3243 {
3245 }
3247
3248 if (PagingIo)
3249 {
3251 }
3252 else if (NoCache)
3253 {
3255 }
3256 else
3257 {
3259 }
3260 }
3261
3262 /* A pagefile cannot be a pipe */
3265 {
3267 }
3268
3269 /* Null-length read is no-op */
3271 {
3273 }
3274
3275 /* Validate FCB type */
3277 {
3279 }
3280
3281 /* Init the lowio context for possible forward */
3283
3284 PostRequest = FALSE;
3285 ReadCachingDisabled = FALSE;
3286 OwnerSet = FALSE;
3290 _SEH2_TRY
3291 {
3293
3294 /* If no caching, make sure current Cc data have been flushed */
3296 {
3299 {
3300 PostRequest = TRUE;
3301 _SEH2_LEAVE;
3302 }
3304 {
3305 _SEH2_LEAVE;
3306 }
3307
3311
3313 {
3315 _SEH2_LEAVE;
3316 }
3317
3320 }
3321
3322 /* Acquire the appropriate lock */
3323 if (PagingIo && !ReadCachingEnabled)
3324 {
3326
3328 {
3329 PostRequest = TRUE;
3330 _SEH2_LEAVE;
3331 }
3332
3333 if (!CanWait)
3334 {
3336 }
3337 }
3338 else
3339 {
3340 if (!ReadCachingEnabled)
3341 {
3342 if (!CanWait && NoCache)
3343 {
3346 {
3348 PostRequest = TRUE;
3349 _SEH2_LEAVE;
3350 }
3352 {
3354 _SEH2_LEAVE;
3355 }
3356
3358 {
3360 }
3361 else
3362 {
3363 PostRequest = TRUE;
3364 _SEH2_LEAVE;
3365 }
3366 }
3367 else
3368 {
3371 {
3372 PostRequest = TRUE;
3373 _SEH2_LEAVE;
3374 }
3376 {
3377 _SEH2_LEAVE;
3378 }
3379 }
3380 }
3381 }
3382
3383 RxItsTheSameContext();
3384
3385 ReadCachingDisabled = (ReadCachingEnabled == FALSE);
3387 {
3388 UNIMPLEMENTED;
3389 }
3390
3392
3393 /* Make sure FLOCK doesn't conflict */
3394 if (!PagingIo)
3395 {
3397 {
3399 _SEH2_LEAVE;
3400 }
3401 }
3402
3403 /* Validate byteoffset vs length */
3405 {
3407 {
3409 _SEH2_LEAVE;
3410 }
3411
3413 {
3415 }
3416 }
3417
3418 /* Read with Cc! */
3419 if (!PagingIo && !NoCache && ReadCachingEnabled &&
3421 {
3422 /* File was not cached yet, do it */
3424 {
3426 {
3428 _SEH2_LEAVE;
3429 }
3430
3432
3435
3437 {
3439 }
3440 else
3441 {
3444 }
3445
3447 }
3448
3449 /* This should never happen - fix your RDR */
3451 {
3453 ASSERT(CanWait);
3454
3458 }
3459 else
3460 {
3461 /* Map buffer */
3462 SystemBuffer = RxNewMapUserBuffer(RxContext);
3464 {
3466 _SEH2_LEAVE;
3467 }
3468
3470
3471 RxItsTheSameContext();
3472
3473 /* Perform the read */
3475 {
3476 if (!ReadCachingEnabled)
3477 {
3479 }
3480
3481 RxItsTheSameContext();
3482
3483 PostRequest = TRUE;
3484 _SEH2_LEAVE;
3485 }
3486
3487 if (!ReadCachingEnabled)
3488 {
3490 }
3491
3494 }
3495 }
3496 else
3497 {
3498 /* Validate the reading */
3499 if (FileObject->PrivateCacheMap != NULL && BooleanFlagOn(Fcb->FcbState, FCB_STATE_READAHEAD_DEFERRED) &&
3500 ByteOffset.QuadPart >= 4096)
3501 {
3504 }
3505
3506 /* If it's consistent, forward to mini-rdr */
3507 if (Fcb->CachedNetRootType != NET_ROOT_DISK || BooleanFlagOn(Fcb->FcbState, FCB_STATE_READAHEAD_DEFERRED) ||
3509 {
3512
3513 RxItsTheSameContext();
3514
3515 if (InFsp && ReadCachingDisabled)
3516 {
3519 OwnerSet = TRUE;
3520 }
3521
3523
3524 RxItsTheSameContext();
3525 }
3526 else
3527 {
3529 {
3530 ReadLength = 0;
3532 _SEH2_LEAVE;
3533 }
3534
3536 {
3538 }
3539
3540 SystemBuffer = RxNewMapUserBuffer(RxContext);
3543 }
3544 }
3545 }
3546 _SEH2_FINALLY
3547 {
3548 RxItsTheSameContext();
3549
3550 /* Post if required */
3551 if (PostRequest)
3552 {
3555 }
3556 else
3557 {
3558 /* Update FO in case of sync IO */
3560 {
3562 {
3564 }
3565 }
3566 }
3567
3568 /* Set FastIo if read was a success */
3570 {
3572 {
3574 }
3575 }
3576
3577 /* In case we're done (not expected any further processing */
3579 {
3580 /* Release everything that can be */
3581 if (ReadCachingDisabled)
3582 {
3583 if (PagingIo)
3584 {
3585 if (OwnerSet)
3586 {
3588 }
3589 else
3590 {
3592 }
3593 }
3594 else
3595 {
3596 if (OwnerSet)
3597 {
3599 }
3600 else
3601 {
3603 }
3604 }
3605 }
3606
3607 /* Dereference/Delete context */
3608 if (PostRequest)
3609 {
3610 RxDereferenceAndDeleteRxContext(RxContext);
3611 }
3612 else
3613 {
3615 {
3616 RxResumeBlockedOperations_Serially(RxContext, &Fobx->Specific.NamedPipe.ReadSerializationQueue);
3617 }
3618 }
3619
3620 /* We cannot return more than asked */
3622 {
3624 }
3625 }
3626 else
3627 {
3628 ASSERT(!Sync);
3629
3630 RxDereferenceAndDeleteRxContext(RxContext);
3631 }
3632 }
3633 _SEH2_END;
3634
3636}
VOID NTAPI CcMdlRead(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
Definition: mdlsup.c:64
VOID NTAPI CcSetReadAheadGranularity(IN PFILE_OBJECT FileObject, IN ULONG Granularity)
Definition: cachesub.c:36
VOID NTAPI CcFlushCache(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN OPTIONAL PLARGE_INTEGER FileOffset, IN ULONG Length, OUT OPTIONAL PIO_STATUS_BLOCK IoStatus)
Definition: cachesub.c:222
#define ExAcquireResourceSharedLite(res, wait)
Definition: env_spec_w32.h:621
IN PDCB IN PCCB IN VBO IN OUT PULONG OUT PDIRENT OUT PBCB OUT PVBO ByteOffset
Definition: fatprocs.h:731
VOID RxGetFileSizeWithLock(_In_ PFCB Fcb, _Out_ PLONGLONG FileSize)
BOOLEAN NTAPI FsRtlCheckLockForReadAccess(IN PFILE_LOCK FileLock, IN PIRP Irp)
Definition: filelock.c:672
VOID NTAPI CcInitializeCacheMap(IN PFILE_OBJECT FileObject, IN PCC_FILE_SIZES FileSizes, IN BOOLEAN PinAccess, IN PCACHE_MANAGER_CALLBACKS Callbacks, IN PVOID LazyWriteContext)
Definition: fssup.c:195
VOID NTAPI CcSetAdditionalCacheAttributes(IN PFILE_OBJECT FileObject, IN BOOLEAN DisableReadAhead, IN BOOLEAN DisableWriteBehind)
Definition: logsup.c:22
BOOLEAN NTAPI CcCopyRead(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus)
Definition: copysup.c:43
VOID NTAPI ExSetResourceOwnerPointer(IN PERESOURCE Resource, IN PVOID OwnerPointer)
Definition: resource.c:2050
@ RXCONTEXT_FLAG4LOWIO_PIPE_SYNC_OPERATION
Definition: rxcontx.h:333
VOID NTAPI RxResumeBlockedOperations_Serially(_Inout_ PRX_CONTEXT RxContext, _Inout_ PLIST_ENTRY BlockingIoQ)
struct _FOBX::@1958::@1962 DiskFile
struct _FOBX::@1958::@1961 NamedPipe
union _FOBX::@1958 Specific
Definition: mrx.h:280
struct _LOWIO_CONTEXT::@2065::@2066 ReadWrite
union _LOWIO_CONTEXT::@2065 ParamsFor
CACHE_MANAGER_CALLBACKS CacheManagerCallbacks
Definition: rxstruc.h:35
Definition: rxstruc.h:80
volatile ULONG RandomReadOperations
Definition: rxstruc.h:109
LARGE_INTEGER CacheReadBytesRequested
Definition: rxstruc.h:104
LARGE_INTEGER PagingReadBytesRequested
Definition: rxstruc.h:102
LARGE_INTEGER NonPagingReadBytesRequested
Definition: rxstruc.h:103
#define ExInterlockedAddLargeStatistic(Addend, Increment)
Definition: exfuncs.h:850
#define IRP_PAGING_IO
#define IRP_NOCACHE
◆ RxCommonSetEa()
| NTSTATUS NTAPI RxCommonSetEa | ( | PRX_CONTEXT | Context | ) |
◆ RxCommonSetInformation()
| NTSTATUS NTAPI RxCommonSetInformation | ( | PRX_CONTEXT | Context | ) |
Definition at line 3652 of file rdbss.c.
3654{
3657 PFOBX Fobx;
3659 PNET_ROOT NetRoot;
3662 BOOLEAN CanWait, FcbTableAcquired, FcbAcquired;
3663
3664 PAGED_CODE();
3665
3669
3676
3679 FcbTableAcquired = FALSE;
3680 FcbAcquired = FALSE;
3682
3684
3685 _SEH2_TRY
3686 {
3687 /* Valide the node type first */
3690 {
3692 {
3694 {
3696 }
3697 }
3699 {
3701 {
3703 }
3704 else
3705 {
3708 }
3709 }
3710 }
3711
3712 /* We don't autorize advance operation */
3714 {
3716
3718 }
3719
3720 /* For these to classes, we'll have to deal with the FCB table (removal)
3721 * We thus need the exclusive FCB table lock
3722 */
3724 {
3727
3729 {
3732 }
3733
3734 FcbTableAcquired = TRUE;
3735 }
3736
3737 /* Finally, if not paging file, we need exclusive FCB lock */
3739 {
3742 {
3745 }
3747 {
3748 _SEH2_LEAVE;
3749 }
3750
3751 FcbAcquired = TRUE;
3752 }
3753
3755
3756 /* And now, perform the job! */
3758 {
3761 break;
3762
3764 {
3765 PFILE_DISPOSITION_INFORMATION FDI;
3766
3767 /* Check whether user wants deletion */
3768 FDI = Irp->AssociatedIrp.SystemBuffer;
3770 {
3771 /* If so, check whether it's doable */
3773 {
3775 }
3776
3777 /* And if doable, already remove from FCB table */
3779 {
3780 ASSERT(FcbAcquired && FcbTableAcquired);
3782
3784 FcbTableAcquired = FALSE;
3785 }
3786 }
3787
3788 /* If it succeed, perform the operation */
3790 {
3792 }
3793
3794 break;
3795 }
3796
3799 break;
3800
3803 break;
3804
3807 break;
3808
3813 break;
3814
3818 /* If we can wait, try to perform the operation right now */
3819 if (CanWait)
3820 {
3821 /* Of course, collapsing is not doable anymore, file is
3822 * in an inbetween state
3823 */
3825
3826 /* Set the information */
3828 /* If it succeed, drop the current entry from FCB table */
3830 {
3831 ASSERT(FcbAcquired && FcbTableAcquired);
3833 }
3835 }
3836 /* Can't wait? Post for async retry */
3837 else
3838 {
3841 }
3842 break;
3843
3846 {
3848 }
3849 break;
3850
3853 break;
3854
3855 default:
3858
3859 break;
3860 }
3861
3862try_exit: NOTHING;
3863 /* If mini-rdr was OK and wants a re-post on this, do it */
3865 {
3867 {
3869 }
3870 }
3871 }
3872 _SEH2_FINALLY
3873 {
3874 /* Release any acquired lock */
3875 if (FcbAcquired)
3876 {
3878 }
3879
3880 if (FcbTableAcquired)
3881 {
3883 }
3884 }
3885 _SEH2_END;
3886
3887#undef _SEH2_TRY_RETURN
3888
3890}
Definition: mfunptr_test.cpp:53
#define _SEH2_TRY_RETURN(S)
BOOLEAN NTAPI MmCanFileBeTruncated(_In_ PSECTION_OBJECT_POINTERS SectionObjectPointer, _In_opt_ PLARGE_INTEGER NewFileSize)
Definition: section.c:4255
BOOLEAN NTAPI MmFlushImageSection(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN MMFLUSH_TYPE FlushType)
Definition: section.c:4356
Definition: movable.cpp:9
Definition: nt_native.h:972
Definition: compiler.c:64
◆ RxCommonSetQuotaInformation()
| NTSTATUS NTAPI RxCommonSetQuotaInformation | ( | PRX_CONTEXT | Context | ) |
◆ RxCommonSetSecurity()
| NTSTATUS NTAPI RxCommonSetSecurity | ( | PRX_CONTEXT | Context | ) |
◆ RxCommonSetVolumeInformation()
| NTSTATUS NTAPI RxCommonSetVolumeInformation | ( | PRX_CONTEXT | Context | ) |
◆ RxCommonUnimplemented()
| NTSTATUS NTAPI RxCommonUnimplemented | ( | PRX_CONTEXT | Context | ) |
◆ RxCommonWrite()
| NTSTATUS NTAPI RxCommonWrite | ( | PRX_CONTEXT | Context | ) |
Definition at line 3930 of file rdbss.c.
3932{
3935 PFOBX Fobx;
3937 PNET_ROOT NetRoot;
3938 PSRV_OPEN SrvOpen;
3942 NODE_TYPE_CODE NodeTypeCode;
3943 PLOWIO_CONTEXT LowIoContext;
3944 PRDBSS_DEVICE_OBJECT RxDeviceObject;
3947 BOOLEAN CanWait, PagingIo, NoCache, Sync, NormalFile, WriteToEof, IsPipe, NoPreposting, InFsp, RecursiveWriteThrough, CalledByLazyWriter, SwitchBackToAsync, ExtendingFile, ExtendingValidData, UnwindOutstandingAsync, ResourceOwnerSet, PostIrp, ContextReferenced;
3948
3949 PAGED_CODE();
3950
3953 /* Validate FCB type */
3956 {
3958 }
3959
3960 /* We'll write to file, keep track of it */
3962
3963 Stack = RxContext->CurrentIrpSp;
3964 /* Set write through if asked */
3966 {
3968 }
3969
3970 Fobx = (PFOBX)RxContext->pFobx;
3972
3973 /* Get some parameters */
3974 Irp = RxContext->CurrentIrp;
3984 (CanWait ? "CW" : "!CW"), (PagingIo ? "PI" : "!PI"), (NoCache ? "NC" : "!NC"), (Sync ? "S" : "!S"));
3985
3986 RxItsTheSameContext();
3987
3988 RxContext->FcbResourceAcquired = FALSE;
3989 RxContext->FcbPagingIoResourceAcquired = FALSE;
3990
3991 LowIoContext = &RxContext->LowIoContext;
3992 CheckForLoudOperations(RxContext);
3994 {
3998 }
3999
4000 RxDeviceObject = RxContext->RxDeviceObject;
4001 /* Update stats */
4002 if (!BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_IN_FSP) && Fcb->CachedNetRootType == NET_ROOT_DISK)
4003 {
4005
4007 {
4009 }
4011
4012 if (PagingIo)
4013 {
4015 }
4016 else if (NoCache)
4017 {
4019 }
4020 else
4021 {
4023 }
4024 }
4025
4028 /* Keep track for normal writes */
4030 {
4031 NormalFile = TRUE;
4032 }
4033 else
4034 {
4035 NormalFile = FALSE;
4036 }
4037
4038 /* Zero-length write is immediate success */
4040 {
4042 }
4043
4044 /* Check whether we have input data */
4046 {
4048 }
4049
4050 /* Are we writting to EOF? */
4051 WriteToEof = ((ByteOffset.LowPart == FILE_WRITE_TO_END_OF_FILE) && (ByteOffset.HighPart == -1));
4052 /* FIXME: validate length/offset */
4053
4054 /* Get our SRV_OPEN in case of normal write */
4056 {
4057 SrvOpen = (PSRV_OPEN)Fobx->pSrvOpen;
4058 }
4059 else
4060 {
4061 SrvOpen = NULL;
4062 }
4063
4065
4066 /* If we have caching enabled, check whether we have to defer write */
4067 if (!NoCache)
4068 {
4070 {
4074 {
4075 BOOLEAN Retrying;
4076
4078
4080
4082
4083 CcDeferWrite(FileObject, (PCC_POST_DEFERRED_WRITE)RxAddToWorkque, RxContext, Irp, WriteLength, Retrying);
4084
4086 }
4087 }
4088 }
4089
4090 /* Initialize the low IO context for write */
4092
4093 /* Initialize our (many) booleans */
4094 RecursiveWriteThrough = FALSE;
4095 CalledByLazyWriter = FALSE;
4096 SwitchBackToAsync = FALSE;
4097 ExtendingFile = FALSE;
4098 ExtendingValidData = FALSE;
4099 UnwindOutstandingAsync = FALSE;
4100 ResourceOwnerSet = FALSE;
4101 PostIrp = FALSE;
4102 ContextReferenced = FALSE;
4103
4104#define _SEH2_TRY_RETURN(S) S; goto try_exit
4105
4106 _SEH2_TRY
4107 {
4108 /* No volume FCB here! */
4110 (NodeTypeCode == RDBSS_NTC_SPOOLFILE) ||
4111 (NodeTypeCode == RDBSS_NTC_MAILSLOT));
4112
4113 /* Writing to EOF on a paging file is non sense */
4114 ASSERT(!(WriteToEof && PagingIo));
4115
4116 RxItsTheSameContext();
4117
4118 /* Start locking stuff */
4119 if (!PagingIo && !NoPreposting)
4120 {
4121 /* If it's already acquired, all fine */
4122 if (RxContext->FcbResourceAcquired)
4123 {
4125 }
4126 else
4127 {
4128 /* Otherwise, try to acquire shared (excepted for pipes) */
4130 {
4132 }
4133 else if (CanWait ||
4134 (!NoCache && RxWriteCacheingAllowed(Fcb, SrvOpen)))
4135 {
4137 }
4138 else
4139 {
4141 }
4142
4143 /* We'll post IRP to retry */
4145 {
4146 PostIrp = TRUE;
4149 }
4150
4151 /* We'll just fail */
4153 {
4155 }
4156
4157 /* Resource acquired */
4158 RxContext->FcbResourceAcquired = TRUE;
4159 }
4160
4161 /* At that point, resource is acquired */
4163 {
4164 ASSERT(RxContext->FcbResourceAcquired);
4165 }
4166 else
4167 {
4168 BOOLEAN IsDormant;
4169
4170 /* Now, check whether we have to promote shared lock */
4172 {
4174 }
4175 else
4176 {
4177 IsDormant = FALSE;
4178 }
4179
4180 /* We're writing beyond VDL, we'll need an exclusive lock if not dormant */
4183 {
4184 if (!IsDormant)
4185 {
4187 RxContext->FcbResourceAcquired = FALSE;
4188
4191 {
4192 PostIrp = TRUE;
4195 }
4196
4198 {
4200 }
4201
4202 RxContext->FcbResourceAcquired = TRUE;
4203 }
4204 }
4205
4206 /* If we're writing in VDL, or if we're dormant, shared lock is enough */
4208 IsDormant)
4209 {
4211 {
4213 }
4214 }
4215 else
4216 {
4217 /* We're extending file, disable collapsing */
4219
4221
4223 {
4224 SetFlag(Fobx->Flags, FOBX_FLAG_DISABLE_COLLAPSING);
4225 }
4226 }
4227
4228 ASSERT(RxContext->FcbResourceAcquired);
4229 }
4230
4231 /* Keep track of the acquired resource */
4233 }
4234 else
4235 {
4236 /* Paging IO */
4238
4239 /* Lock the paging resource */
4241
4242 /* Keep track of the acquired resource */
4244 }
4245
4247 {
4248 UNIMPLEMENTED;
4250 }
4251
4252 /* If it's a non cached write, or if caching is disallowed */
4254 {
4255 /* If cache was previously enabled, we'll have to flush before writing */
4257 {
4258 LARGE_INTEGER FlushOffset;
4259
4260 /* FCB is lock */
4262
4263 /* If shared, we'll have to relock exclusive */
4265 {
4266 /* Release and retry exclusive */
4268 RxContext->FcbResourceAcquired = FALSE;
4269
4272 {
4273 PostIrp = TRUE;
4276 }
4277
4279 {
4281 }
4282
4283 RxContext->FcbResourceAcquired = TRUE;
4284 }
4285
4286 /* Get the length to flush */
4287 if (WriteToEof)
4288 {
4290 }
4291 else
4292 {
4294 }
4295
4296 /* Perform the flushing */
4301
4302 /* Cannot continue if flushing failed */
4304 {
4306 }
4307
4308 /* Synchronize */
4311
4312 /* And purge */
4315 }
4316 }
4317
4318 /* If not paging IO, check if write is allowed */
4319 if (!PagingIo)
4320 {
4322 {
4324 }
4325 }
4326
4327 /* Get file sizes */
4331
4332 /* If paging IO, we cannot write past file size
4333 * so fix write length if needed
4334 */
4335 if (PagingIo)
4336 {
4338 {
4340 }
4341
4343 {
4345 }
4346 }
4347
4348 /* If we're being called by the lazywrite */
4350 {
4351 CalledByLazyWriter = TRUE;
4352
4353 /* Fail if we're beyong VDL */
4355 {
4358 {
4359 if (ByteOffset.QuadPart + WriteLength > ((ValidDataLength + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)))
4360 {
4362 }
4363 }
4364 }
4365 }
4366
4367 /* If that's a recursive synchronous page write */
4370 {
4371 PIRP TopIrp;
4372
4373 /* Check the top level IRP on the FastIO path */
4374 TopIrp = RxGetTopIrpIfRdbssIrp();
4376 {
4377 PIO_STACK_LOCATION IrpStack;
4378
4380
4381 /* If the top level IRP was a cached write for this file, keep track */
4382 IrpStack = IoGetCurrentIrpStackLocation(TopIrp);
4385 {
4386 RecursiveWriteThrough = TRUE;
4388 }
4389 }
4390 }
4391
4392 /* Now, deal with file size and VDL */
4393 if (!CalledByLazyWriter && !RecursiveWriteThrough &&
4395 {
4396 /* Not sync? Let's make it sync, just the time we extended */
4397 if (!Sync)
4398 {
4399 CanWait = TRUE;
4402 Sync = TRUE;
4403
4404 /* Keep track we'll have to switch back to async */
4405 if (NoCache)
4406 {
4407 SwitchBackToAsync = TRUE;
4408 }
4409 }
4410
4411 /* Release all the locks */
4412 RxWriteReleaseResources(RxContext, 0);
4413
4414 /* Acquire exclusive */
4417 {
4418 PostIrp = TRUE;
4421 }
4422
4424 {
4426 }
4427
4428 RxContext->FcbResourceAcquired = TRUE;
4429
4430 RxItsTheSameContext();
4431
4432 /* Get the sizes again, to be sure they didn't change in the meantime */
4436
4437 /* Check we can switch back to async? */
4440 {
4441 SwitchBackToAsync = FALSE;
4442 }
4443
4444 /* If paging IO, check we don't try to extend the file */
4445 if (PagingIo)
4446 {
4448 {
4450 }
4451
4453 {
4455 }
4456 }
4457 }
4458
4459 /* Save our initial sizes for potential rollback */
4460 InitialFileSize = FileSize;
4461 InitialValidDataLength = ValidDataLength;
4462 /* If writing to EOF, update byte offset with file size */
4463 if (WriteToEof)
4464 {
4466 }
4467
4468 /* Check again whether we're allowed to write */
4469 if (!PagingIo)
4470 {
4472 {
4474 }
4475
4476 /* Do we have to extend? */
4478 {
4480 ExtendingFile = TRUE;
4482 }
4483 }
4484
4485 /* Let's start to extend */
4486 if (ExtendingFile)
4487 {
4488 /* If we're past allocating, inform mini-rdr */
4491 {
4492 LARGE_INTEGER NewAllocationSize;
4493
4495
4496 if (NoCache)
4497 {
4501 }
4502 else
4503 {
4507 }
4508
4510 {
4512 }
4513
4515 {
4517 }
4518
4519 /* And update FCB */
4521 }
4522
4523 /* Set the new sizes */
4526
4527 /* And inform Cc */
4529 {
4531 }
4532 }
4533
4534 /* Do we have to extend VDL? */
4535 if (!CalledByLazyWriter && !RecursiveWriteThrough)
4536 {
4538 {
4539 ExtendingValidData = TRUE;
4541 }
4542 }
4543
4544 /* If none cached write */
4546 {
4547 /* Switch back to async, if asked to */
4548 if (SwitchBackToAsync)
4549 {
4550 CanWait = FALSE;
4551 Sync = FALSE;
4552
4555 }
4556
4557 /* If not synchronous, keep track of writes to be finished */
4558 if (!Sync)
4559 {
4561 {
4565 }
4566
4568 1,
4569 &RxStrucSupSpinLock) == 0)
4570 {
4572 }
4573
4574 UnwindOutstandingAsync = TRUE;
4576 }
4577
4578 /* Set our LOWIO_CONTEXT information */
4581
4582 RxItsTheSameContext();
4583
4584 /* We have to be locked */
4585 ASSERT(RxContext->FcbResourceAcquired || RxContext->FcbPagingIoResourceAcquired);
4586
4587 /* Update thread ID if we're in FSP */
4588 if (InFsp)
4589 {
4591
4592 if (RxContext->FcbResourceAcquired)
4593 {
4595 }
4596
4597 if (RxContext->FcbPagingIoResourceAcquired)
4598 {
4600 }
4601
4602 ResourceOwnerSet = TRUE;
4603 }
4604
4605 /* And perform the write */
4607
4608 RxItsTheSameContext();
4609
4610 /* Not outstanding write anymore */
4612 {
4613 UnwindOutstandingAsync = FALSE;
4614 }
4615 }
4616 /* Cached write */
4617 else
4618 {
4619 /* If cache wasn't enabled yet, do it */
4621 {
4623 {
4625 }
4626
4628
4631
4633 }
4634
4635 /* If that's a MDL backed write */
4637 {
4638 /* Shouldn't happen */
4640 ASSERT(CanWait);
4641
4642 /* Perform it, though */
4645
4647 }
4648 else
4649 {
4650 PVOID SystemBuffer;
4651 ULONG BreakpointsSave;
4652
4653 /* Map the user buffer */
4654 SystemBuffer = RxNewMapUserBuffer(RxContext);
4656 {
4658 }
4659
4660 RxSaveAndSetExceptionNoBreakpointFlag(RxContext, BreakpointsSave);
4661
4662 RxItsTheSameContext();
4663
4664 /* And deal with Cc */
4666 SystemBuffer))
4667 {
4668 RxRestoreExceptionNoBreakpointFlag(RxContext, BreakpointsSave);
4669
4670 RxItsTheSameContext();
4671
4674
4675 PostIrp = TRUE;
4676 }
4677 else
4678 {
4681
4682 RxRestoreExceptionNoBreakpointFlag(RxContext, BreakpointsSave);
4683
4684 RxItsTheSameContext();
4685
4688 }
4689 }
4690 }
4691
4692try_exit: NOTHING;
4693
4694 /* If we've to post the IRP */
4695 if (PostIrp)
4696 {
4697 /* Reset the file size if required */
4699 {
4702
4706
4708 {
4710 }
4711 }
4712
4714 ContextReferenced = TRUE;
4715
4716 /* Release locks */
4717 ASSERT(!ResourceOwnerSet);
4718 RxWriteReleaseResources(RxContext, ResourceOwnerSet);
4719
4720#ifdef RDBSS_TRACKER
4721 ASSERT(RxContext->AcquireReleaseFcbTrackerX == 0);
4722#endif
4723
4724 /* And post the request */
4726 }
4727 else
4728 {
4730 {
4731 /* Update FILE_OBJECT if synchronous write succeed */
4732 if (!PagingIo)
4733 {
4735 {
4737 }
4738 }
4739
4740 /* If write succeed, ,also update FILE_OBJECT flags */
4742 {
4743 /* File was modified */
4744 if (!PagingIo)
4745 {
4747 }
4748
4749 /* If was even extended */
4750 if (ExtendingFile)
4751 {
4753 }
4754
4755 /* If VDL was extended, update FCB and inform Cc */
4756 if (ExtendingValidData)
4757 {
4758 LONGLONG LastOffset;
4759
4762 {
4763 LastOffset = FileSize;
4764 }
4765
4767
4769 {
4771 }
4772 }
4773 }
4774 }
4775 }
4776 }
4777 _SEH2_FINALLY
4778 {
4779 /* Finally, if we failed while extension was required */
4781 {
4782 /* Rollback! */
4784 {
4786
4791
4793 {
4795 }
4796 }
4797 }
4798
4799 /* One async write less */
4800 if (UnwindOutstandingAsync)
4801 {
4803
4806 }
4807
4808 /* And now, cleanup everything */
4810 {
4811 /* If we didn't post, release every lock (for posting, it's already done) */
4812 if (!PostIrp)
4813 {
4814 RxWriteReleaseResources(RxContext, ResourceOwnerSet);
4815 }
4816
4817 /* If the context was referenced - posting, dereference it */
4818 if (ContextReferenced)
4819 {
4820 RxDereferenceAndDeleteRxContext(RxContext);
4821 }
4822
4823 /* If that's a pipe operation, resume any blocked one */
4824 if (!PostIrp)
4825 {
4827 {
4828 RxResumeBlockedOperations_Serially(RxContext, &Fobx->Specific.NamedPipe.ReadSerializationQueue);
4829 }
4830 }
4831
4832 /* Sanity check for write */
4834 {
4836 }
4837 }
4838 /* Just dereference our context */
4839 else
4840 {
4841 ASSERT(!Sync);
4842 RxDereferenceAndDeleteRxContext(RxContext);
4843 }
4844 }
4845 _SEH2_END;
4846
4847#undef _SEH2_TRY_RETURN
4848
4850}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
Definition: Bus_PDO_EvalMethod.c:150
VOID NTAPI CcPrepareMdlWrite(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
Definition: mdlsup.c:91
Definition: Header.h:9
VOID RxSetFileSizeWithLock(_Inout_ PFCB Fcb, _In_ PLONGLONG FileSize)
struct _FOBX * PFOBX
BOOLEAN NTAPI FsRtlCheckLockForWriteAccess(IN PFILE_LOCK FileLock, IN PIRP Irp)
Definition: filelock.c:710
BOOLEAN NTAPI CcPurgeCacheSection(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN OPTIONAL PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN UninitializeCacheMaps)
Definition: fssup.c:386
ULONG NTAPI ExInterlockedAddUlong(IN OUT PULONG Addend, IN ULONG Increment, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:88
#define LOWIO_READWRITEFLAG_EXTENDING_FILESIZE
Definition: mrx.h:326
BOOLEAN NTAPI CcCopyWrite(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN PVOID Buffer)
Definition: copysup.c:129
BOOLEAN NTAPI CcCanIWrite(IN PFILE_OBJECT FileObject, IN ULONG BytesToWrite, IN BOOLEAN Wait, IN UCHAR Retrying)
Definition: copysup.c:214
VOID NTAPI CcDeferWrite(IN PFILE_OBJECT FileObject, IN PCC_POST_DEFERRED_WRITE PostRoutine, IN PVOID Context1, IN PVOID Context2, IN ULONG BytesToWrite, IN BOOLEAN Retrying)
Definition: copysup.c:225
VOID NTAPI RxAddToWorkque(IN PRX_CONTEXT RxContext, IN PIRP Irp)
Definition: rdbss.c:772
#define RxRestoreExceptionNoBreakpointFlag(R, F)
Definition: rxcontx.h:358
#define RxSaveAndSetExceptionNoBreakpointFlag(R, F)
Definition: rxcontx.h:357
#define RxAcquirePagingIoResourceShared(RxContext, Fcb, Flag)
Definition: rxprocs.h:242
volatile ULONG RandomWriteOperations
Definition: rxstruc.h:117
LARGE_INTEGER NonPagingWriteBytesRequested
Definition: rxstruc.h:111
LARGE_INTEGER PagingWriteBytesRequested
Definition: rxstruc.h:110
LARGE_INTEGER CacheWriteBytesRequested
Definition: rxstruc.h:112
VOID(NTAPI * PCC_POST_DEFERRED_WRITE)(_In_ PVOID Context1, _In_ PVOID Context2)
Definition: cctypes.h:66
#define IO_TYPE_IRP
#define IRP_SYNCHRONOUS_PAGING_IO
◆ RxCompleteMdl()
| NTSTATUS NTAPI RxCompleteMdl | ( | IN PRX_CONTEXT | RxContext | ) |
Definition at line 4857 of file rdbss.c.
4859{
4863
4864#define BugCheckFileId RDBSS_BUG_CHECK_CACHESUP
4865
4866 PAGED_CODE();
4867
4868 Irp = RxContext->CurrentIrp;
4869 Stack = RxContext->CurrentIrpSp;
4871
4872 /* We can only complete for IRP_MJ_READ and IRP_MJ_WRITE */
4873 switch (RxContext->MajorFunction)
4874 {
4875 /* Call the Cc function */
4878 break;
4879
4881 /* If here, we can wait */
4883
4884 /* Call the Cc function */
4886
4888 break;
4889
4890 default:
4892 RxBugCheck(RxContext->MajorFunction, 0, 0);
4893 break;
4894 }
4895
4896 /* MDL was freed */
4898
4899 /* And complete the IRP */
4901
4902#undef BugCheckFileId
4903
4905}
VOID NTAPI CcMdlReadComplete(IN PFILE_OBJECT FileObject, IN PMDL MdlChain)
Definition: mdlsup.c:75
VOID NTAPI CcMdlWriteComplete(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain)
Definition: mdlsup.c:102
Referenced by RxFsdCommonDispatch().
◆ RxConjureOriginalName()
| VOID RxConjureOriginalName | ( | PFCB | Fcb, |
| PFOBX | Fobx, | ||
| PULONG | ActualNameLength, | ||
| PWCHAR | OriginalName, | ||
| PLONG | LengthRemaining, | ||
| RX_NAME_CONJURING_METHODS | NameConjuringMethod | ||
| ) |
Definition at line 4911 of file rdbss.c.
4918{
4920 PV_NET_ROOT VNetRoot;
4921 USHORT PrefixLength, NameLength, ToCopy;
4922
4923 PAGED_CODE();
4924
4926 /* We will use the prefix contained in NET_ROOT, if we don't have
4927 * a V_NET_ROOT, or if it wasn't null deviced or if we already have
4928 * a UNC path */
4931 {
4934 NameLength = 0;
4935
4936 /* In that case, keep track that we will have a prefix as buffer */
4937 NameConjuringMethod = VNetRoot_As_Prefix;
4938 }
4939 else
4940 {
4942
4943 /* Otherwise, return the prefix from our V_NET_ROOT */
4947
4948 /* If we want a UNC path, skip potential device */
4950 {
4951 do
4952 {
4953 ++Prefix;
4956 }
4957 }
4958
4959 /* If we added an extra backslash, skip it */
4961 {
4963 }
4964
4965 /* If we're asked for a drive letter, skip the prefix */
4967 {
4968 PrefixLength = 0;
4969
4970 /* And make sure we arrive at a backslash */
4973 {
4975 }
4976 }
4977 else
4978 {
4979 /* Prepare to copy the prefix, make sure not to overflow */
4980 if (*LengthRemaining >= PrefixLength)
4981 {
4982 /* Copy everything */
4983 ToCopy = PrefixLength;
4984 *LengthRemaining = *LengthRemaining - PrefixLength;
4985 }
4986 else
4987 {
4988 /* Copy as much as we can */
4989 ToCopy = *LengthRemaining;
4990 /* And return failure */
4991 *LengthRemaining = -1;
4992 }
4993
4994 /* Copy the prefix */
4996 }
4997
4998 /* Do we have a name to copy now? */
5000 {
5003 }
5004 else
5005 {
5006 /* Just use slash for now */
5008 NameLength = 0;
5010 }
5011
5012 /* Total length we will have in the output buffer (if everything is alright) */
5013 *ActualNameLength = ToCopy + PrefixLength;
5014 /* If we still have room to write data */
5015 if (*LengthRemaining != -1)
5016 {
5017 /* If we can copy everything, it's fine! */
5018 if (*LengthRemaining > ToCopy)
5019 {
5020 *LengthRemaining = *LengthRemaining - ToCopy;
5021 }
5022 /* Otherwise, copy as much as possible, and return failure */
5023 else
5024 {
5025 ToCopy = *LengthRemaining;
5026 *LengthRemaining = -1;
5027 }
5028
5029 /* Copy name after the prefix */
5032 }
5033}
Definition: apinames.c:49
Referenced by RxQueryNameInfo().
◆ RxCopyCreateParameters()
| VOID RxCopyCreateParameters | ( | IN PRX_CONTEXT | RxContext | ) |
Definition at line 5039 of file rdbss.c.
5041{
5043 PVOID DfsContext;
5046 PDFS_NAME_CONTEXT DfsNameContext;
5047 PIO_SECURITY_CONTEXT SecurityContext;
5048
5049 Irp = RxContext->CurrentIrp;
5050 Stack = RxContext->CurrentIrpSp;
5052 SecurityContext = Stack->Parameters.Create.SecurityContext;
5053
5054 RxContext->Create.NtCreateParameters.SecurityContext = SecurityContext;
5055 if (SecurityContext->AccessState != NULL && SecurityContext->AccessState->SecurityDescriptor != NULL)
5056 {
5057 RxContext->Create.SdLength = RtlLengthSecurityDescriptor(SecurityContext->AccessState->SecurityDescriptor);
5059 RxContext->Create.SdLength);
5060 }
5062 {
5063 RxContext->Create.NtCreateParameters.ImpersonationLevel = SecurityContext->SecurityQos->ImpersonationLevel;
5064 }
5065 else
5066 {
5067 RxContext->Create.NtCreateParameters.ImpersonationLevel = SecurityImpersonation;
5068 }
5069 RxContext->Create.NtCreateParameters.DesiredAccess = SecurityContext->DesiredAccess;
5070
5071 RxContext->Create.NtCreateParameters.AllocationSize.QuadPart = Irp->Overlay.AllocationSize.QuadPart;
5072 RxContext->Create.NtCreateParameters.FileAttributes = Stack->Parameters.Create.FileAttributes & FILE_ATTRIBUTE_VALID_FLAGS;
5073 RxContext->Create.NtCreateParameters.ShareAccess = Stack->Parameters.Create.ShareAccess & FILE_SHARE_VALID_FLAGS;
5074 RxContext->Create.NtCreateParameters.Disposition = (Stack->Parameters.Create.Options >> 24) & 0x000000FF;
5075 RxContext->Create.NtCreateParameters.CreateOptions = Stack->Parameters.Create.Options & 0xFFFFFF;
5076
5077 DfsContext = FileObject->FsContext2;
5078 DfsNameContext = FileObject->FsContext;
5079 RxContext->Create.NtCreateParameters.DfsContext = DfsContext;
5080 RxContext->Create.NtCreateParameters.DfsNameContext = DfsNameContext;
5091
5092 RxContext->pFcb = NULL;
5093 RxContext->Create.ReturnedCreateInformation = 0;
5094
5095 /* if we stripped last \, it has to be a directory! */
5096 if (BooleanFlagOn(RxContext->Create.Flags, RX_CONTEXT_CREATE_FLAG_STRIPPED_TRAILING_BACKSLASH))
5097 {
5099 }
5100
5101 RxContext->Create.EaLength = Stack->Parameters.Create.EaLength;
5102 if (RxContext->Create.EaLength == 0)
5103 {
5104 RxContext->Create.EaBuffer = NULL;
5105 }
5106 else
5107 {
5108 RxContext->Create.EaBuffer = Irp->AssociatedIrp.SystemBuffer;
5109 DPRINT("EA Buffer: %p, Length: %lx\n", Irp->AssociatedIrp.SystemBuffer, RxContext->Create.EaLength);
5110 }
5111}
NTSYSAPI ULONG WINAPI RtlLengthSecurityDescriptor(PSECURITY_DESCRIPTOR)
Definition: dfs.h:12
Definition: iotypes.h:2865
SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
Definition: lsa.idl:65
Referenced by RxCommonCreate().
◆ RxCreateFromNetRoot()
| NTSTATUS RxCreateFromNetRoot | ( | PRX_CONTEXT | Context, |
| PUNICODE_STRING | NetRootName | ||
| ) |
Definition at line 5114 of file rdbss.c.
5117{
5120 PNET_ROOT NetRoot;
5125
5126 PAGED_CODE();
5127
5128 /* Validate that the context is consistent */
5130 {
5132 }
5133
5136 {
5138 }
5139
5142 {
5144 }
5145
5148 {
5150 }
5151
5155 {
5157 }
5158
5160
5161 /* Get file object */
5163
5164 /* Do we have to open target directory for renaming? */
5166 {
5168
5169 /* If we have been asked for delete, try to purge first */
5171 {
5174 }
5175
5176 /* Create the FCB */
5179 {
5181 }
5182
5183 /* Fake it: it will be used only renaming */
5187
5188 /* Assign it to the FO */
5190
5191 /* If we have a FOBX already, check whether it's for DFS opening */
5193 {
5194 /* If so, reflect this in the FOBX */
5196 {
5198 }
5199 else
5200 {
5202 }
5203 }
5204
5205 /* Acquire the FCB */
5208 {
5210 }
5211
5212 /* Reference the FCB and release */
5215
5216 /* We're done! */
5218 }
5219
5220 /* Try to find (or create) the FCB for the file */
5224 {
5226 }
5228 {
5230 }
5231
5233 {
5235 }
5236 else
5237 {
5239 }
5240
5241 /* If finding FCB worked (mailslot case), mark the FCB as good and quit */
5243 {
5249 }
5250
5251 /* Not mailslot! */
5252 /* Check SA for conflict */
5254 {
5258 {
5261 }
5262 }
5263
5266 {
5267 UNIMPLEMENTED;
5268 }
5269
5270 _SEH2_TRY
5271 {
5272 /* Find a SRV_OPEN that suits the opening */
5275 {
5276 PFOBX Fobx;
5277 PSRV_OPEN SrvOpen;
5278
5281 /* There are already opens, check for conflict */
5283 {
5287 "2ndAccPerUO")))
5288 {
5289 ++SrvOpen->UncleanFobxCount;
5291
5292 _SEH2_LEAVE;
5293 }
5294 }
5295 else
5296 {
5298 {
5301 }
5302 }
5303
5305
5306 /* No conflict? Set up SA */
5308 {
5310 }
5311
5314 {
5315 ++Fcb->UncachedUncleanCount;
5316 }
5317
5320 {
5322 }
5323
5324 /* No pending close, we're active */
5326
5328 ++SrvOpen->UncleanFobxCount;
5329 ++SrvOpen->OpenCount;
5331
5333 {
5336
5339
5341 }
5342
5343 /* Now, update SA for the SRV_OPEN */
5344 RxUpdateShareAccessPerSrvOpens(SrvOpen);
5345
5347 {
5349 }
5350
5351 /* Update the FOBX info */
5353 {
5355 {
5357 }
5358
5361 {
5363
5365 Fobx->Specific.NamedPipe.CollectDataSize = Context->Create.pNetRoot->NamedPipeParameters.DataCollectionSize;
5366
5369 Fobx->Specific.NamedPipe.PipeHandleInformation.CompletionMode = Context->Create.PipeCompletionMode;
5370
5373 }
5374 }
5375
5377 }
5378 }
5379 _SEH2_FINALLY
5380 {
5382 {
5384 {
5386 Context,
5387 FALSE,
5388 FALSE) == 0);
5390 {
5392 }
5393 }
5394 }
5395 else
5396 {
5398 }
5399 }
5400 _SEH2_END;
5401
5403}
PFCB RxCreateNetFcb(_In_ PRX_CONTEXT RxContext, _In_ PV_NET_ROOT VNetRoot, _In_ PUNICODE_STRING Name)
#define SRVOPEN_FLAG_NO_BUFFERING_STATE_CHANGE
Definition: mrxfcb.h:139
#define SRVOPEN_FLAG_DONTUSE_WRITE_CACHING
Definition: mrxfcb.h:131
VOID RxUpdateShareAccessPerSrvOpens(IN PSRV_OPEN SrvOpen)
Definition: rdbss.c:9506
NTSTATUS RxCollapseOrCreateSrvOpen(PRX_CONTEXT RxContext)
Definition: rdbss.c:1732
NTSTATUS RxFindOrCreateFcb(PRX_CONTEXT RxContext, PUNICODE_STRING NetRootName)
Definition: rdbss.c:5869
NTSTATUS NTAPI RxChangeBufferingState(PSRV_OPEN SrvOpen, PVOID Context, BOOLEAN ComputeNewState)
Definition: rxce.c:783
Referenced by RxCommonCreate().
◆ RxCreateTreeConnect()
| NTSTATUS RxCreateTreeConnect | ( | IN PRX_CONTEXT | RxContext | ) |
Definition at line 5409 of file rdbss.c.
5411{
5413 PV_NET_ROOT VNetRoot;
5416 NET_ROOT_TYPE NetRootType;
5418
5419 PAGED_CODE();
5420
5421 Stack = RxContext->CurrentIrpSp;
5423
5424 RtlInitEmptyUnicodeString(&CanonicalName, NULL, 0);
5425 /* As long as we don't know connection type, mark it wild */
5426 NetRootType = NET_ROOT_WILD;
5427 /* Get the type by parsing the name */
5430 {
5432 }
5433
5434 RxContext->Create.ThisIsATreeConnectOpen = TRUE;
5435 RxContext->Create.TreeConnectOpenDeferred = FALSE;
5436 RtlInitEmptyUnicodeString(&RxContext->Create.TransportName, NULL, 0);
5437 RtlInitEmptyUnicodeString(&RxContext->Create.UserName, NULL, 0);
5438 RtlInitEmptyUnicodeString(&RxContext->Create.Password, NULL, 0);
5439 RtlInitEmptyUnicodeString(&RxContext->Create.UserDomainName, NULL, 0);
5440
5441 /* We don't handle EA - they come from DFS, don't care */
5443 {
5444 UNIMPLEMENTED;
5445 }
5446
5447 /* Mount if required */
5448 Status = RxFindOrConstructVirtualNetRoot(RxContext, &CanonicalName, NetRootType, &RemainingName);
5450 {
5451 RxScavengeVNetRoots(RxContext->RxDeviceObject);
5452 Status = RxFindOrConstructVirtualNetRoot(RxContext, &CanonicalName, NetRootType, &RemainingName);
5453 }
5454
5456 {
5458 }
5459
5460 /* Validate the rest of the name with mini-rdr */
5462 {
5464 RxContext->Create.pNetRoot->pSrvCall->RxDeviceObject->Dispatch,
5465 MRxIsValidDirectory, (RxContext, &RemainingName));
5466 }
5467
5469 {
5471 }
5472
5473 VNetRoot = (PV_NET_ROOT)RxContext->Create.pVNetRoot;
5474 RxReferenceVNetRoot(VNetRoot);
5476 {
5478 }
5479
5481 FileObject->FsContext2 = VNetRoot;
5482
5483 VNetRoot->ConstructionStatus = STATUS_SUCCESS;
5484 ++VNetRoot->NumberOfOpens;
5485
5486 /* Create is over - clear context */
5487 RxContext->Create.pSrvCall = NULL;
5488 RxContext->Create.pNetRoot = NULL;
5489 RxContext->Create.pVNetRoot = NULL;
5490
5492}
#define STATUS_NETWORK_CREDENTIAL_CONFLICT
Definition: ntstatus.h:638
BOOLEAN RxScavengeVNetRoots(_In_ PRDBSS_DEVICE_OBJECT RxDeviceObject)
volatile LONG AdditionalReferenceForDeleteFsctlTaken
Definition: fcb.h:71
Referenced by RxCommonCreate().
◆ RxDebugControlCommand()
Definition at line 5496 of file rdbss.c.
Referenced by RxGetRegistryParameters().
◆ RxDriverEntry()
| NTSTATUS NTAPI RxDriverEntry | ( | IN PDRIVER_OBJECT | DriverObject, |
| IN PUNICODE_STRING | RegistryPath | ||
| ) |
Definition at line 5504 of file rdbss.c.
5507{
5510
5512
5513 _SEH2_TRY
5514 {
5515 RxCheckFcbStructuresForAlignment();
5516
5521
5525
5528
5529 RxInitializeDebugSupport();
5530
5533
5534 RxInitializeLog();
5535 State = 2;
5536
5538 RxReadRegistryParameters();
5539
5542 {
5543 _SEH2_LEAVE;
5544 }
5545 State = 1;
5546
5547 RxInitializeDispatcher();
5548
5549 ExInitializeNPagedLookasideList(&RxContextLookasideList, RxAllocatePoolWithTag, RxFreePool, 0, sizeof(RX_CONTEXT), RX_IRPC_POOLTAG, 4);
5550
5553
5556
5561
5563 {
5567 }
5568
5570
5572
5575
5576 RxInitializeRxTimer();
5577 }
5578 _SEH2_FINALLY
5579 {
5581 {
5584 }
5585 } _SEH2_END;
5586
5587 /* There are still bits to init - be consider it's fine for now */
5588#if 0
5589 UNIMPLEMENTED;
5591#else
5593#endif
5594}
VOID NTAPI ExInitializeNPagedLookasideList(IN PNPAGED_LOOKASIDE_LIST Lookaside, IN PALLOCATE_FUNCTION Allocate OPTIONAL, IN PFREE_FUNCTION Free OPTIONAL, IN ULONG Flags, IN SIZE_T Size, IN ULONG Tag, IN USHORT Depth)
Definition: lookas.c:218
VOID NTAPI KeInitializeMutex(IN PKMUTEX Mutex, IN ULONG Level)
Definition: mutex.c:67
VOID NTAPI RxGetRegistryParameters(IN PUNICODE_STRING RegistryPath)
Definition: rdbss.c:6695
VOID NTAPI RxInitUnwind(PDRIVER_OBJECT DriverObject, USHORT State)
Definition: rdbss.c:6991
UCHAR RxSpaceForTheWrappersDeviceObject[sizeof(*RxFileSystemDeviceObject)]
Definition: rdbss.c:610
NTSTATUS NTAPI RxInitializeRegistrationStructures(VOID)
Definition: rdbss.c:6964
VOID NTAPI RxCheckFcbStructuresForAlignment(VOID)
Definition: rdbss.c:1447
VOID NTAPI RxInitializeDispatchVectors(PDRIVER_OBJECT DriverObject)
Definition: rdbss.c:6894
FAST_MUTEX RxContextPerFileSerializationMutex
Definition: rxce.c:146
struct _RDBSS_DEVICE_OBJECT * PRDBSS_DEVICE_OBJECT
Definition: stack_allocator.h:18
_Must_inspect_result_ _In_ PDRIVER_OBJECT _In_ PCUNICODE_STRING RegistryPath
Definition: wdfdriver.h:215
FORCEINLINE VOID ExInitializeFastMutex(_Out_ PFAST_MUTEX FastMutex)
Definition: exfuncs.h:274
◆ RxFastIoCheckIfPossible()
| BOOLEAN NTAPI RxFastIoCheckIfPossible | ( | PFILE_OBJECT | FileObject, |
| PLARGE_INTEGER | FileOffset, | ||
| ULONG | Length, | ||
| BOOLEAN | Wait, | ||
| ULONG | LockKey, | ||
| BOOLEAN | CheckForReadOperation, | ||
| PIO_STATUS_BLOCK | IoStatus, | ||
| PDEVICE_OBJECT | DeviceObject | ||
| ) |
Definition at line 5630 of file rdbss.c.
5637{
5639 PSRV_OPEN SrvOpen;
5640 LARGE_INTEGER LargeLength;
5641
5642 PAGED_CODE();
5643
5644 /* Get the FCB to validate it */
5647 {
5650 }
5651
5653 {
5656 }
5657
5658 /* If there's a pending write operation, deny fast operation */
5660 {
5663 }
5664
5665 /* Deny read on orphaned node */
5668 {
5671 }
5672
5674 {
5677 }
5678
5679 /* If there's a buffering state change pending, deny fast operation (it might change
5680 * cache status)
5681 */
5683 {
5686 }
5687
5688 /* File got renamed/deleted, deny operation */
5691 {
5694 }
5695
5696 /* Process pending change buffering state operations */
5697 FsRtlEnterFileSystem();
5698 RxProcessChangeBufferingStateRequestsForSrvOpen(SrvOpen);
5699 FsRtlExitFileSystem();
5700
5702
5703 /* If operation to come is a read operation */
5705 {
5706 /* Check that read cache is enabled */
5708 {
5711 }
5712
5713 /* Check whether there's a lock conflict */
5715 FileOffset,
5716 &LargeLength,
5717 LockKey,
5718 FileObject,
5719 PsGetCurrentProcess()))
5720 {
5723 }
5724
5726 }
5727
5728 /* Check that write cache is enabled */
5730 {
5733 }
5734
5735 /* Check whether there's a lock conflict */
5737 FileOffset,
5738 &LargeLength,
5739 LockKey,
5740 FileObject,
5741 PsGetCurrentProcess()))
5742 {
5745 }
5746
5748}
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 FsRtlEnterFileSystem
#define FsRtlExitFileSystem
VOID RxProcessChangeBufferingStateRequestsForSrvOpen(PSRV_OPEN SrvOpen)
Definition: rxce.c:6655
Referenced by RxInitializeDispatchVectors().
◆ RxFastIoDeviceControl()
| BOOLEAN NTAPI RxFastIoDeviceControl | ( | PFILE_OBJECT | FileObject, |
| BOOLEAN | Wait, | ||
| PVOID InputBuffer | OPTIONAL, | ||
| ULONG | InputBufferLength, | ||
| PVOID OutputBuffer | OPTIONAL, | ||
| ULONG | OutputBufferLength, | ||
| ULONG | IoControlCode, | ||
| PIO_STATUS_BLOCK | IoStatus, | ||
| PDEVICE_OBJECT | DeviceObject | ||
| ) |
Definition at line 5752 of file rdbss.c.
5762{
5763 /* Only supported IOCTL */
5765 {
5766 UNIMPLEMENTED;
5768 }
5769 else
5770 {
5772 }
5773}
_In_ WDFREQUEST _In_ size_t _In_ size_t _In_ ULONG IoControlCode
Definition: wdfio.h:325
#define IOCTL_LMR_ARE_FILE_OBJECTS_ON_SAME_SERVER
Definition: iotypes.h:7253
Referenced by RxInitializeDispatchVectors().
◆ RxFastIoRead()
| BOOLEAN NTAPI RxFastIoRead | ( | PFILE_OBJECT | FileObject, |
| PLARGE_INTEGER | FileOffset, | ||
| ULONG | Length, | ||
| BOOLEAN | Wait, | ||
| ULONG | LockKey, | ||
| PVOID | Buffer, | ||
| PIO_STATUS_BLOCK | IoStatus, | ||
| PDEVICE_OBJECT | DeviceObject | ||
| ) |
Definition at line 5780 of file rdbss.c.
5789{
5790 BOOLEAN Ret;
5791 RX_TOPLEVELIRP_CONTEXT TopLevelContext;
5792
5793 PAGED_CODE();
5794
5796 FileObject->FsContext2);
5798
5799 /* Prepare a TLI context */
5803
5806 if (Ret)
5807 {
5809 }
5810 else
5811 {
5813 }
5814
5815 return Ret;
5816}
__in UCHAR __in POWER_STATE __in_opt PVOID __in PIO_STATUS_BLOCK IoStatus
Definition: mxum.h:159
#define RxInitializeTopLevelIrpContext(a, b, c)
Definition: rxcontx.h:38
BOOLEAN FsRtlCopyRead2(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, IN PVOID TopLevelContext)
Definition: copysup.c:40
Referenced by RxInitializeDispatchVectors().
◆ RxFastIoWrite()
| BOOLEAN NTAPI RxFastIoWrite | ( | PFILE_OBJECT | FileObject, |
| PLARGE_INTEGER | FileOffset, | ||
| ULONG | Length, | ||
| BOOLEAN | Wait, | ||
| ULONG | LockKey, | ||
| PVOID | Buffer, | ||
| PIO_STATUS_BLOCK | IoStatus, | ||
| PDEVICE_OBJECT | DeviceObject | ||
| ) |
Definition at line 5823 of file rdbss.c.
5832{
5833 PFOBX Fobx;
5834 BOOLEAN Ret;
5835 RX_TOPLEVELIRP_CONTEXT TopLevelContext;
5836
5837 PAGED_CODE();
5838
5841 {
5843 }
5844
5846 FileObject->FsContext2);
5848
5849 /* Prepare a TLI context */
5853
5856 if (Ret)
5857 {
5859 }
5860 else
5861 {
5863 }
5864
5865 return Ret;
5866}
BOOLEAN FsRtlCopyWrite2(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, IN PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject, IN PVOID TopLevelContext)
Definition: copysup.c:190
Referenced by RxInitializeDispatchVectors().
◆ RxFindOrCreateFcb()
| NTSTATUS RxFindOrCreateFcb | ( | PRX_CONTEXT | RxContext, |
| PUNICODE_STRING | NetRootName | ||
| ) |
Definition at line 5869 of file rdbss.c.
5872{
5876 PNET_ROOT NetRoot;
5877 PV_NET_ROOT VNetRoot;
5878 BOOLEAN TableAcquired, AcquiredExclusive;
5879
5880 PAGED_CODE();
5881
5885
5887 AcquiredExclusive = FALSE;
5888
5890 TableAcquired = TRUE;
5892
5893 /* Look for a cached FCB */
5896 {
5898 }
5899 else
5900 {
5902 /* If FCB was to be orphaned, consider it as not suitable */
5904 {
5907
5909 TableAcquired = TRUE;
5910 AcquiredExclusive = TRUE;
5911
5914 {
5918 }
5919 }
5920 }
5921
5922 /* If FCB was not found or is not covering full path, prepare for more work */
5924 {
5926 {
5927 DPRINT1("FCB was found and it's not covering the whole path: %wZ - %wZ\n", &Fcb->FcbTableEntry.Path, NetRootName);
5928 }
5929
5930 if (!AcquiredExclusive)
5931 {
5934 TableAcquired = TRUE;
5935 }
5936
5937 /* If FCB table was updated in between, re-attempt a lookup */
5939 {
5942 {
5944 }
5945 }
5946 }
5947
5948 /* Allocate the FCB */
5949 _SEH2_TRY
5950 {
5952 {
5955 {
5957 }
5958 else
5959 {
5962 }
5963 }
5964 }
5965 _SEH2_FINALLY
5966 {
5968 {
5970 TableAcquired = FALSE;
5971
5973 {
5975
5978 {
5980 }
5981 }
5982 }
5983 }
5984 _SEH2_END;
5985
5986 if (TableAcquired)
5987 {
5989 }
5990
5992 {
5994 }
5995
5998
6000 {
6004 }
6005
6007}
#define ExAcquireResourceExclusiveLite(res, wait)
Definition: env_spec_w32.h:615
PFCB RxFcbTableLookupFcb(_In_ PRX_FCB_TABLE FcbTable, _In_ PUNICODE_STRING Path)
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1822
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE _In_ USHORT _In_ USHORT Version
Definition: wdffdo.h:469
Referenced by RxCreateFromNetRoot().
◆ RxFirstCanonicalize()
| NTSTATUS RxFirstCanonicalize | ( | PRX_CONTEXT | RxContext, |
| PUNICODE_STRING | FileName, | ||
| PUNICODE_STRING | CanonicalName, | ||
| PNET_ROOT_TYPE | NetRootType | ||
| ) |
Definition at line 6010 of file rdbss.c.
6015{
6018 BOOLEAN UncName, PrependString, IsSpecial;
6019 USHORT CanonicalLength;
6020 UNICODE_STRING SessionIdString;
6021 WCHAR SessionIdBuffer[16];
6022
6023 PAGED_CODE();
6024
6026 PrependString = FALSE;
6027 IsSpecial = FALSE;
6028 UncName = FALSE;
6030
6031 /* Name has to contain at least \\ */
6033 {
6035 }
6036
6037 /* First easy check, is that a path with a name? */
6038 CanonicalLength = FileName->Length;
6040 {
6042 {
6044 {
6046 }
6047 else
6048 {
6050 }
6051 }
6052 }
6053
6054 /* Nope, attempt deeper parsing */
6056 {
6058 PWSTR FirstSlash, EndOfString;
6059
6061 UncName = TRUE;
6062
6063 /* The lack of drive letter will be replaced by session ID */
6065 RtlInitEmptyUnicodeString(&SessionIdString, SessionIdBuffer, sizeof(SessionIdBuffer));
6067
6070 {
6072 {
6073 break;
6074 }
6075 }
6076
6077 if (EndOfString - FirstSlash <= 1)
6078 {
6080 }
6081 else
6082 {
6083 UNIMPLEMENTED;
6087 //Status = STATUS_NOT_IMPLEMENTED;
6088 /* Should be check against IPC, mailslot, and so on */
6089 }
6090 }
6091
6092 /* Update net root type with our deduced one */
6093 *NetRootType = Type;
6095
6097 {
6099 }
6100
6101 /* Do we have to prepend session ID? */
6102 if (UncName)
6103 {
6104 if (!IsSpecial)
6105 {
6106 PrependString = TRUE;
6108 }
6109 }
6110
6111 /* If not UNC path, we should preprend stuff */
6113 {
6115 }
6116
6117 /* Allocate the buffer */
6120 {
6122 }
6123
6124 /* We don't support that case, we always return disk */
6125 if (IsSpecial)
6126 {
6128 UNIMPLEMENTED;
6130 }
6131 else
6132 {
6133 /* If we have to prepend, go ahead */
6134 if (PrependString)
6135 {
6140 RtlAppendUnicodeStringToString(CanonicalName, &SessionIdString);
6142
6144 }
6145 /* Otherwise, that's a simple copy */
6146 else
6147 {
6149 }
6150 }
6151
6153}
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
NTSYSAPI NTSTATUS NTAPI RtlIntegerToUnicodeString(ULONG Value, ULONG Base, PUNICODE_STRING String)
NTSTATUS RxAllocateCanonicalNameBuffer(PRX_CONTEXT RxContext, PUNICODE_STRING CanonicalName, USHORT CanonicalLength)
Definition: rdbss.c:924
Referenced by RxCanonicalizeNameAndObtainNetRoot(), RxCreateTreeConnect(), and RxPrefixClaim().
◆ RxFreeCanonicalNameBuffer()
| VOID RxFreeCanonicalNameBuffer | ( | PRX_CONTEXT | Context | ) |
Definition at line 6159 of file rdbss.c.
6161{
6162 /* These two buffers are always the same */
6164
6166 {
6170 }
6171
6173}
Referenced by RxCanonicalizeNameAndObtainNetRoot(), and RxpPrepareCreateContextForReuse().
◆ RxFsdCommonDispatch()
| NTSTATUS RxFsdCommonDispatch | ( | PRX_FSD_DISPATCH_VECTOR | DispatchVector, |
| UCHAR | MajorFunction, | ||
| PIO_STACK_LOCATION | Stack, | ||
| PFILE_OBJECT | FileObject, | ||
| PIRP | Irp, | ||
| PRDBSS_DEVICE_OBJECT | RxDeviceObject | ||
| ) |
Definition at line 6176 of file rdbss.c.
6183{
6188 PFILE_OBJECT StackFileObject;
6189 PRX_FSD_DISPATCH DispatchFunc;
6190 RX_TOPLEVELIRP_CONTEXT TopLevelContext;
6192
6194
6195 DPRINT("RxFsdCommonDispatch(%p, %d, %p, %p, %p, %p)\n", DispatchVector, MajorFunction, Stack, FileObject, Irp, RxDeviceObject);
6196
6197 FsRtlEnterFileSystem();
6198
6200
6201 _SEH2_TRY
6202 {
6203 CanWait = TRUE;
6204 Closing = FALSE;
6205 PostRequest = FALSE;
6206 SetCancelRoutine = TRUE;
6208 /* Can we wait? */
6210 {
6213 {
6215 }
6216 else
6217 {
6218 CanWait = TRUE;
6219 }
6220 break;
6221
6237 break;
6238
6241 Closing = TRUE;
6242 SetCancelRoutine = FALSE;
6243 break;
6244
6245 default:
6246 break;
6247 }
6248
6250 /* Should we stop it right now, or mini-rdr deserves to know? */
6251 PassToDriver = TRUE;
6253 {
6255 {
6256 PassToDriver = FALSE;
6259 }
6260 }
6261 else
6262 {
6263 if (DispatchVector != RxDeviceFCBVector && (FileObject->FileName.Length != 0 || FileObject->RelatedFileObject != NULL))
6264 {
6265 PassToDriver = FALSE;
6268 }
6269 }
6271
6272 StackFileObject = Stack->FileObject;
6273 /* Make sure we don't deal with orphaned stuff */
6275 {
6278 StackFileObject->FsContext != &RxDeviceFCB)
6279 {
6281 PFOBX Fobx;
6282
6283 Fcb = StackFileObject->FsContext;
6284 Fobx = StackFileObject->FsContext2;
6285
6288 {
6289 if (Closing)
6290 {
6291 PassToDriver = TRUE;
6292 }
6293 else
6294 {
6295 PassToDriver = FALSE;
6298 }
6299 }
6300 }
6301 }
6302
6303 /* Did we receive a close request whereas we're stopping? */
6305 {
6307
6308 Fcb = StackFileObject->FsContext;
6309
6313
6316 {
6319 }
6320 }
6321
6322 /* Should we stop the whole thing now? */
6323 if (!PassToDriver)
6324 {
6326 {
6329 Irp->IoStatus.Information = 0;
6332 }
6333 else
6334 {
6336 Irp->IoStatus.Information = 0;
6338 }
6339
6340 _SEH2_LEAVE;
6341 }
6342
6343 /* No? Allocate a context to deal with the mini-rdr */
6346 {
6349 _SEH2_LEAVE;
6350 }
6351
6352 /* Set cancel routine if required */
6353 if (SetCancelRoutine)
6354 {
6357 }
6358 else
6359 {
6362 }
6364
6366
6368 Irp->IoStatus.Information = 0;
6369 /* Get the dispatch routine */
6371
6373 {
6374 /* Handle the complete MDL case */
6376 {
6377 DispatchFunc = RxCompleteMdl;
6378 }
6379 else
6380 {
6381 /* Do we have to post request? */
6383 {
6384 PostRequest = TRUE;
6385 }
6386 else
6387 {
6388 /* Our read function needs stack, make sure we won't overflow,
6389 * otherwise, post the request
6390 */
6392 {
6393 if (IoGetRemainingStackSize() < 0xE00)
6394 {
6398 {
6401 }
6402
6403 _SEH2_LEAVE;
6404 }
6405 }
6406 }
6407 }
6408 }
6409
6410 Context->ResumeRoutine = DispatchFunc;
6411 /* There's a dispatch routine? Time to dispatch! */
6413 {
6415 if (PostRequest)
6416 {
6418 }
6419 else
6420 {
6421 /* Retry as long as we have */
6422 do
6423 {
6425 }
6427
6429 {
6430 _SEH2_LEAVE;
6431 }
6432
6433 /* Sanity check: did someone mess with our context? */
6436 {
6442 }
6445 }
6446 }
6447 else
6448 {
6450 }
6451 }
6452 _SEH2_FINALLY
6453 {
6455 {
6456 RxUnwindTopLevelIrp(&TopLevelContext);
6457 }
6458
6459 FsRtlExitFileSystem();
6460 }
6461 _SEH2_END;
6462
6465}
IoMarkIrpPending(Irp)
IoSetCancelRoutine(Irp, CancelRoutine)
VOID RxUnwindTopLevelIrp(IN OUT PRX_TOPLEVELIRP_CONTEXT TopLevelContext)
Definition: rdbss.c:9471
NTSTATUS RxPostStackOverflowRead(IN PRX_CONTEXT RxContext)
Definition: rdbss.c:7641
VOID NTAPI RxCancelRoutine(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: rdbss.c:1196
BOOLEAN RxTryToBecomeTheTopLevelIrp(IN OUT PRX_TOPLEVELIRP_CONTEXT TopLevelContext, IN PIRP Irp, IN PRDBSS_DEVICE_OBJECT RxDeviceObject, IN BOOLEAN ForceTopLevel)
Definition: rdbss.c:9348
RX_FSD_DISPATCH_VECTOR RxDeviceFCBVector[IRP_MJ_MAXIMUM_FUNCTION+1]
Definition: rdbss.c:540
VOID RxCompleteRequest_Real(_In_ PRX_CONTEXT RxContext, _In_ PIRP Irp, _In_ NTSTATUS Status)
#define IRP_MJ_QUERY_EA
#define IRP_MJ_FILE_SYSTEM_CONTROL
#define IRP_MJ_SET_VOLUME_INFORMATION
#define IRP_MN_REMOVE_DEVICE
#define IRP_MJ_QUERY_SECURITY
#define IRP_MJ_SET_EA
#define IRP_MJ_FLUSH_BUFFERS
#define IRP_MJ_SET_SECURITY
#define IRP_MJ_CLEANUP
#define IRP_MJ_MAXIMUM_FUNCTION
Referenced by RxFsdDispatch().
◆ RxFsdDispatch()
Definition at line 6472 of file rdbss.c.
6475{
6478 PRX_FSD_DISPATCH_VECTOR DispatchVector;
6479
6480 PAGED_CODE();
6481
6483
6485
6486 /* Dispatch easy case */
6488 {
6490 }
6491
6492 /* Bail out broken cases */
6495 {
6497 Irp->IoStatus.Information = 0;
6501 }
6502
6503 /* Immediately handle create */
6505 {
6506 return RxFsdCommonDispatch(&RxFsdDispatchVector[0], Stack->MajorFunction, Stack, Stack->FileObject, Irp, RxDeviceObject);
6507 }
6508
6509 /* If not a creation, we must have at least a FO with a FCB */
6511 {
6513 Irp->IoStatus.Information = 0;
6517 }
6518
6519 /* Set the dispatch vector if required */
6522 {
6523 DispatchVector = &RxFsdDispatchVector[0];
6524 }
6525 else
6526 {
6528 }
6529
6530 /* Device cannot accept such requests */
6532 {
6534 Irp->IoStatus.Information = 0;
6538 }
6539
6540 /* Dispatch for real! */
6541 return RxFsdCommonDispatch(DispatchVector, Stack->MajorFunction, Stack, Stack->FileObject, Irp, RxDeviceObject);
6542}
NTSTATUS RxSystemControl(IN PRDBSS_DEVICE_OBJECT RxDeviceObject, IN PIRP Irp)
Definition: rdbss.c:9336
RX_FSD_DISPATCH_VECTOR RxFsdDispatchVector[IRP_MJ_MAXIMUM_FUNCTION+1]
Definition: rdbss.c:574
NTSTATUS RxFsdCommonDispatch(PRX_FSD_DISPATCH_VECTOR DispatchVector, UCHAR MajorFunction, PIO_STACK_LOCATION Stack, PFILE_OBJECT FileObject, PIRP Irp, PRDBSS_DEVICE_OBJECT RxDeviceObject)
Definition: rdbss.c:6176
Definition: rdbss.c:46
#define IRP_MJ_CREATE_NAMED_PIPE
#define IRP_MJ_CREATE_MAILSLOT
#define IRP_MJ_SYSTEM_CONTROL
Referenced by RxInitializeDispatchVectors().
◆ RxFsdPostRequest()
| NTSTATUS RxFsdPostRequest | ( | IN PRX_CONTEXT | RxContext | ) |
Definition at line 6548 of file rdbss.c.
6550{
6551 /* Initialize posting if required */
6553 {
6554 RxPrePostIrp(RxContext, RxContext->CurrentIrp);
6555 }
6556
6558 RxContext->MinorFunction, RxContext,
6559 RxContext->CurrentIrp, RxContext->LastExecutionThread,
6560 RxContext->SerialNumber);
6561
6562 RxAddToWorkque(RxContext, RxContext->CurrentIrp);
6564}
Referenced by RxCommonDevFCBIoCtl(), RxCommonQueryVolumeInformation(), RxCommonSetInformation(), RxCommonWrite(), RxFsdCommonDispatch(), and RxQueryDirectory().
◆ RxFspDispatch()
Definition at line 6571 of file rdbss.c.
6573{
6574 KIRQL EntryIrql;
6576 PRDBSS_DEVICE_OBJECT VolumeDO;
6578
6579 PAGED_CODE();
6580
6581 RxContext = Context;
6583 /* Save IRQL at entry for later checking */
6584 EntryIrql = KeGetCurrentIrql();
6585
6586 /* No FO, deal with device */
6588 {
6589 VolumeDO = RxFileSystemDeviceObject;
6590 }
6591 else
6592 {
6593 VolumeDO = NULL;
6594 }
6595
6596 /* Which queue to used for delayed? */
6598 {
6600 }
6601 else
6602 {
6605 }
6606
6607 do
6608 {
6611 BOOLEAN RecursiveCall;
6612 RX_TOPLEVELIRP_CONTEXT TopLevelContext;
6613
6616
6619
6622 RxContext->SerialNumber);
6623
6625
6626 FsRtlEnterFileSystem();
6627
6629 RxTryToBecomeTheTopLevelIrp(&TopLevelContext,
6632
6634
6636 {
6637 ASSERT((RxContext->MajorFunction == IRP_MJ_WRITE) || (RxContext->MajorFunction == IRP_MJ_READ));
6639 }
6640
6641 /* Call the resume routine */
6642 do
6643 {
6644 BOOLEAN NoComplete;
6645
6647
6650 {
6652 {
6654 }
6655 }
6656 }
6658
6659 RxUnwindTopLevelIrp(&TopLevelContext);
6660 FsRtlExitFileSystem();
6661
6663 {
6665 }
6666 else
6667 {
6668 RxContext = NULL;
6669 }
6671
6672 /* Did we mess with IRQL? */
6674 {
6676 }
6677}
PRX_CONTEXT RxRemoveOverflowEntry(PRDBSS_DEVICE_OBJECT DeviceObject, WORK_QUEUE_TYPE Queue)
Definition: rdbss.c:8580
Referenced by RxAddToWorkque().
◆ RxGetNetworkProviderPriority()
| ULONG RxGetNetworkProviderPriority | ( | PUNICODE_STRING | DeviceName | ) |
Definition at line 6683 of file rdbss.c.
Referenced by RxRegisterMinirdr().
◆ RxGetRegistryParameters()
| VOID NTAPI RxGetRegistryParameters | ( | IN PUNICODE_STRING | RegistryPath | ) |
Definition at line 6695 of file rdbss.c.
6697{
6704
6705 PAGED_CODE();
6706
6708 Status = ZwOpenKey(&DriverHandle, READ_CONTROL | KEY_NOTIFY | KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE, &ObjectAttributes);
6710 {
6711 return;
6712 }
6713
6715 InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE, DriverHandle, FALSE);
6716 Status = ZwOpenKey(&KeyHandle, READ_CONTROL | KEY_NOTIFY | KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE, &ObjectAttributes);
6718 {
6719 /* The only parameter we deal with is InitialDebugString */
6720 RxGetStringRegistryParameter(KeyHandle, L"InitialDebugString", &OutString, Buffer, sizeof(Buffer), 0);
6722 {
6725
6729 {
6731 ++Write;
6733 ++Read;
6734 }
6735
6736 /* Which is a string we'll just write out */
6739 }
6740
6742 }
6743
6745}
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4715
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define ANSI_NULL
VOID NTAPI RxDebugControlCommand(_In_ PSTR ControlString)
Definition: rdbss.c:5496
NTSTATUS NTAPI RxGetStringRegistryParameter(IN HANDLE KeyHandle, IN PCWSTR KeyName, OUT PUNICODE_STRING OutString, IN PUCHAR Buffer, IN ULONG BufferLength, IN BOOLEAN LogFailure)
Definition: rdbss.c:6787
Definition: umtypes.h:182
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName
Definition: wdfdevice.h:2699
Referenced by RxDriverEntry().
◆ RxGetSessionId()
| ULONG RxGetSessionId | ( | IN PIO_STACK_LOCATION | IrpSp | ) |
Definition at line 6751 of file rdbss.c.
6753{
6756 PIO_SECURITY_CONTEXT SecurityContext;
6757
6758 PAGED_CODE();
6759
6760 /* If that's not a prefix claim, not an open request, session id will be 0 */
6761 if (IrpSp->MajorFunction != IRP_MJ_DEVICE_CONTROL || IrpSp->Parameters.DeviceIoControl.IoControlCode != IOCTL_REDIR_QUERY_PATH)
6762 {
6764 {
6765 return 0;
6766 }
6767
6769 }
6770 else
6771 {
6772 SecurityContext = ((PQUERY_PATH_REQUEST)IrpSp->Parameters.DeviceIoControl.Type3InputBuffer)->SecurityContext;
6773 }
6774
6775 /* Query the session id */
6778
6780}
Definition: tokenizer.hpp:28
struct _QUERY_PATH_REQUEST * PQUERY_PATH_REQUEST
NTSTATUS NTAPI SeQuerySessionIdToken(_In_ PACCESS_TOKEN Token, _Out_ PULONG pSessionId)
Queries the session ID of an access token.
Definition: token.c:2004
SECURITY_SUBJECT_CONTEXT SubjectSecurityContext
Definition: setypes.h:234
struct _IO_STACK_LOCATION::@1564::@1565 DeviceIoControl
union _IO_STACK_LOCATION::@1564 Parameters
struct _IO_STACK_LOCATION::@3978::@3979 Create
#define SeQuerySubjectContextToken(SubjectContext)
Definition: sefuncs.h:583
Referenced by RxFirstCanonicalize().
◆ RxGetStringRegistryParameter()
| NTSTATUS NTAPI RxGetStringRegistryParameter | ( | IN HANDLE | KeyHandle, |
| IN PCWSTR | KeyName, | ||
| OUT PUNICODE_STRING | OutString, | ||
| IN PUCHAR | Buffer, | ||
| IN ULONG | BufferLength, | ||
| IN BOOLEAN | LogFailure | ||
| ) |
Definition at line 6787 of file rdbss.c.
6794{
6797 UNICODE_STRING KeyString;
6798
6799 PAGED_CODE();
6800
6802 Status = ZwQueryValueKey(KeyHandle, &KeyString, KeyValuePartialInformation, Buffer, BufferLength, &ResultLength);
6803 OutString->Length = 0;
6804 OutString->Buffer = 0;
6806 {
6807 if (LogFailure)
6808 {
6810 }
6811
6813 }
6814
6816 OutString->Length = ((PKEY_VALUE_PARTIAL_INFORMATION)Buffer)->DataLength - sizeof(UNICODE_NULL);
6817 OutString->MaximumLength = OutString->Length;
6818
6820}
struct _KEY_VALUE_PARTIAL_INFORMATION * PKEY_VALUE_PARTIAL_INFORMATION
#define UNICODE_NULL
Definition: nt_native.h:1165
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG _Out_ PULONG ResultLength
Definition: wdfdevice.h:3776
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3771
Referenced by RxGetRegistryParameters().
◆ RxGetTopDeviceObjectIfRdbssIrp()
| PRDBSS_DEVICE_OBJECT RxGetTopDeviceObjectIfRdbssIrp | ( | VOID | ) |
Definition at line 6826 of file rdbss.c.
6828{
6829 PIRP TopLevelIrp;
6831
6832 TopLevelIrp = IoGetTopLevelIrp();
6834 {
6835 TopDevice = ((PRX_TOPLEVELIRP_CONTEXT)TopLevelIrp)->RxDeviceObject;
6836 }
6837
6838 return TopDevice;
6839}
BOOLEAN RxIsThisAnRdbssTopLevelContext(PRX_TOPLEVELIRP_CONTEXT TopLevelContext)
Definition: rdbss.c:7075
struct _RX_TOPLEVELIRP_CONTEXT * PRX_TOPLEVELIRP_CONTEXT
Referenced by RxInitializeContext().
◆ RxGetTopIrpIfRdbssIrp()
Definition at line 6845 of file rdbss.c.
6847{
6850
6853 {
6855 }
6856
6858}
Referenced by RxCommonWrite(), RxReleaseFcbFromLazyWrite(), and RxReleaseFcbFromReadAhead().
◆ RxGetUid()
| LUID RxGetUid | ( | IN PSECURITY_SUBJECT_CONTEXT | SubjectSecurityContext | ) |
Definition at line 6864 of file rdbss.c.
6866{
6867 LUID Luid;
6869
6870 PAGED_CODE();
6871
6874
6875 return Luid;
6876}
NTSTATUS NTAPI SeQueryAuthenticationIdToken(_In_ PACCESS_TOKEN Token, _Out_ PLUID LogonId)
Queries the authentication ID of an access token.
Definition: token.c:2036
Definition: devicetopology.idl:137
Referenced by RxStartMinirdr().
◆ RxIndicateChangeOfBufferingStateForSrvOpen()
| VOID NTAPI RxIndicateChangeOfBufferingStateForSrvOpen | ( | PMRX_SRV_CALL | SrvCall, |
| PMRX_SRV_OPEN | SrvOpen, | ||
| PVOID | SrvOpenKey, | ||
| PVOID | Context | ||
| ) |
Definition at line 6880 of file rdbss.c.
Referenced by fcbopen_main(), and nfs41_invalidate_cache().
◆ RxInitializeDebugSupport()
Definition at line 4677 of file rxce.c.
4679{
4680 /* Nothing to do */
4681}
Referenced by RxDriverEntry().
◆ RxInitializeDispatchVectors()
| VOID NTAPI RxInitializeDispatchVectors | ( | PDRIVER_OBJECT | DriverObject | ) |
Definition at line 6894 of file rdbss.c.
6896{
6898
6899 PAGED_CODE();
6900
6902 {
6904 }
6905
6909
6926
6927 RxInitializeTopLevelIrpPackage();
6928
6933
6938}
VOID NTAPI RxReleaseFileForNtCreateSection(PFILE_OBJECT FileObject)
Definition: rxce.c:7578
NTSTATUS NTAPI RxReleaseForCcFlush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject)
Definition: rxce.c:7586
BOOLEAN NTAPI RxFastIoCheckIfPossible(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, ULONG LockKey, BOOLEAN CheckForReadOperation, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject)
Definition: rdbss.c:5630
NTSTATUS NTAPI RxFsdDispatch(IN PRDBSS_DEVICE_OBJECT RxDeviceObject, IN PIRP Irp)
Definition: rdbss.c:6472
BOOLEAN NTAPI RxFastIoWrite(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, ULONG LockKey, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject)
Definition: rdbss.c:5823
VOID NTAPI RxAcquireFileForNtCreateSection(PFILE_OBJECT FileObject)
Definition: rxce.c:276
BOOLEAN NTAPI RxFastIoDeviceControl(PFILE_OBJECT FileObject, BOOLEAN Wait, PVOID InputBuffer OPTIONAL, ULONG InputBufferLength, PVOID OutputBuffer OPTIONAL, ULONG OutputBufferLength, ULONG IoControlCode, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject)
Definition: rdbss.c:5752
VOID NTAPI RxInitializeTopLevelIrpPackage(VOID)
Definition: rdbss.c:6982
BOOLEAN NTAPI RxFastIoRead(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, ULONG LockKey, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject)
Definition: rdbss.c:5780
NTSTATUS NTAPI RxAcquireForCcFlush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject)
Definition: rxce.c:284
VOID NTAPI RxNoOpRelease(_In_ PVOID Fcb)
VOID NTAPI RxReleaseFcbFromReadAhead(_In_ PVOID Null)
BOOLEAN NTAPI RxAcquireFcbForReadAhead(_In_ PVOID Null, _In_ BOOLEAN Wait)
BOOLEAN NTAPI RxNoOpAcquire(_In_ PVOID Fcb, _In_ BOOLEAN Wait)
BOOLEAN NTAPI RxAcquireFcbForLazyWrite(_In_ PVOID Null, _In_ BOOLEAN Wait)
VOID NTAPI RxReleaseFcbFromLazyWrite(_In_ PVOID Null)
PACQUIRE_FOR_LAZY_WRITE AcquireForLazyWrite
Definition: cctypes.h:39
PRELEASE_FROM_LAZY_WRITE ReleaseFromLazyWrite
Definition: cctypes.h:40
PACQUIRE_FOR_READ_AHEAD AcquireForReadAhead
Definition: cctypes.h:41
PRELEASE_FROM_READ_AHEAD ReleaseFromReadAhead
Definition: cctypes.h:42
PFAST_IO_QUERY_STANDARD_INFO FastIoQueryStandardInfo
Definition: iotypes.h:1738
PFAST_IO_UNLOCK_ALL_BY_KEY FastIoUnlockAllByKey
Definition: iotypes.h:1742
PFAST_IO_RELEASE_FOR_CCFLUSH ReleaseForCcFlush
Definition: iotypes.h:1760
PFAST_IO_ACQUIRE_FOR_CCFLUSH AcquireForCcFlush
Definition: iotypes.h:1759
PFAST_IO_DEVICE_CONTROL FastIoDeviceControl
Definition: iotypes.h:1743
PFAST_IO_ACQUIRE_FILE AcquireFileForNtCreateSection
Definition: iotypes.h:1744
PFAST_IO_QUERY_BASIC_INFO FastIoQueryBasicInfo
Definition: iotypes.h:1737
PFAST_IO_UNLOCK_SINGLE FastIoUnlockSingle
Definition: iotypes.h:1740
PFAST_IO_RELEASE_FILE ReleaseFileForNtCreateSection
Definition: iotypes.h:1745
PFAST_IO_CHECK_IF_POSSIBLE FastIoCheckIfPossible
Definition: iotypes.h:1734
CACHE_MANAGER_CALLBACKS CacheManagerNoOpCallbacks
Definition: rxstruc.h:37
Referenced by RxDriverEntry().
◆ RxInitializeLog()
Definition at line 6942 of file rdbss.c.
Referenced by RxDriverEntry().
◆ RxInitializeMinirdrDispatchTable()
| VOID RxInitializeMinirdrDispatchTable | ( | IN PDRIVER_OBJECT | DriverObject | ) |
Definition at line 6953 of file rdbss.c.
Referenced by RxRegisterMinirdr().
◆ RxInitializeRegistrationStructures()
Definition at line 6964 of file rdbss.c.
Referenced by RxDriverEntry().
◆ RxInitializeTopLevelIrpPackage()
◆ RxInitUnwind()
| VOID NTAPI RxInitUnwind | ( | PDRIVER_OBJECT | DriverObject, |
| USHORT | State | ||
| ) |
Definition at line 6991 of file rdbss.c.
Referenced by RxDriverEntry().
◆ RxIsMemberOfTopLevelIrpAllocatedContextsList()
| BOOLEAN RxIsMemberOfTopLevelIrpAllocatedContextsList | ( | PRX_TOPLEVELIRP_CONTEXT | TopLevelContext | ) |
Definition at line 7002 of file rdbss.c.
7004{
7006 PLIST_ENTRY NextEntry;
7008 PRX_TOPLEVELIRP_CONTEXT ListContext;
7009
7010 /* Browse all the allocated TLC to find ours */
7013 NextEntry != &TopLevelIrpAllocatedContextsList;
7014 NextEntry = NextEntry->Flink)
7015 {
7019
7020 /* Found! */
7021 if (ListContext == TopLevelContext)
7022 {
7024 break;
7025 }
7026 }
7028
7030}
Referenced by RxIsThisAnRdbssTopLevelContext().
◆ RxIsOkToPurgeFcb()
Definition at line 7036 of file rdbss.c.
7038{
7040
7041 /* No associated SRV_OPEN, it's OK to purge */
7043 {
7045 }
7046
7047 /* Only allow to purge if all the associated SRV_OPEN
7048 * - have no outstanding opens ongoing
7049 * - have only read attribute set
7050 */
7054 {
7055 PSRV_OPEN SrvOpen;
7056
7058
7059 /* Failing previous needs, don't allow purge */
7060 if (SrvOpen->UncleanFobxCount != 0 ||
7061 (SrvOpen->DesiredAccess & 0xFFEFFFFF) != FILE_READ_ATTRIBUTES)
7062 {
7064 }
7065 }
7066
7067 /* All correct, allow purge */
7069}
Referenced by RxSearchForCollapsibleOpen().
◆ RxIsThisAnRdbssTopLevelContext()
| BOOLEAN RxIsThisAnRdbssTopLevelContext | ( | PRX_TOPLEVELIRP_CONTEXT | TopLevelContext | ) |
Definition at line 7075 of file rdbss.c.
7077{
7078 ULONG_PTR StackTop, StackBottom;
7079
7080 /* Bail out for flags */
7082 {
7084 }
7085
7086 /* Is our provided TLC allocated on stack? */
7087 IoGetStackLimits(&StackTop, &StackBottom);
7089 (ULONG_PTR)TopLevelContext >= StackTop)
7090 {
7091 /* Yes, so check whether it's really a TLC by checking alignement & signature */
7092 if (!BooleanFlagOn((ULONG_PTR)TopLevelContext, 0x3) && TopLevelContext->Signature == RX_TOPLEVELIRP_CONTEXT_SIGNATURE)
7093 {
7095 }
7096
7098 }
7099
7100 /* No, use the helper function */
7102}
VOID NTAPI IoGetStackLimits(OUT PULONG_PTR LowLimit, OUT PULONG_PTR HighLimit)
Definition: util.c:78
BOOLEAN RxIsMemberOfTopLevelIrpAllocatedContextsList(PRX_TOPLEVELIRP_CONTEXT TopLevelContext)
Definition: rdbss.c:7002
Referenced by RxGetTopDeviceObjectIfRdbssIrp(), RxGetTopIrpIfRdbssIrp(), RxIsThisTheTopLevelIrp(), and RxUnwindTopLevelIrp().
◆ RxIsThisTheTopLevelIrp()
Definition at line 7108 of file rdbss.c.
7110{
7111 PIRP TopLevelIrp;
7112
7113 /* When we put oursleves as top level, we set TLC as 'IRP', so look for it */
7114 TopLevelIrp = IoGetTopLevelIrp();
7116 {
7118 }
7119
7121}
Referenced by RxFastIoRead(), and RxFastIoWrite().
◆ RxLockOperationCompletion()
◆ RxLogEventDirect()
| VOID NTAPI RxLogEventDirect | ( | IN PRDBSS_DEVICE_OBJECT | DeviceObject, |
| IN PUNICODE_STRING | OriginatorId, | ||
| IN ULONG | EventId, | ||
| IN NTSTATUS | Status, | ||
| IN ULONG | Line | ||
| ) |
Definition at line 7138 of file rdbss.c.
7144{
7145 PUNICODE_STRING Originator = OriginatorId;
7146 LARGE_INTEGER LargeLine;
7147
7148 /* Set optional parameters */
7151 {
7152 Originator = (PUNICODE_STRING)&unknownId;
7153 }
7154
7155 /* And log */
7156 RxLogEventWithAnnotation(DeviceObject, EventId, Status, &LargeLine, sizeof(LargeLine), Originator, 1);
7157}
VOID NTAPI RxLogEventWithAnnotation(IN PRDBSS_DEVICE_OBJECT DeviceObject, IN ULONG EventId, IN NTSTATUS Status, IN PVOID DataBuffer, IN USHORT DataBufferLength, IN PUNICODE_STRING Annotation, IN ULONG AnnotationCount)
Definition: rdbss.c:7161
◆ RxLogEventWithAnnotation()
| VOID NTAPI RxLogEventWithAnnotation | ( | IN PRDBSS_DEVICE_OBJECT | DeviceObject, |
| IN ULONG | EventId, | ||
| IN NTSTATUS | Status, | ||
| IN PVOID | DataBuffer, | ||
| IN USHORT | DataBufferLength, | ||
| IN PUNICODE_STRING | Annotation, | ||
| IN ULONG | AnnotationCount | ||
| ) |
Definition at line 7161 of file rdbss.c.
Referenced by RxLogEventDirect().
◆ RxLowIoCompletion()
| NTSTATUS NTAPI RxLowIoCompletion | ( | PRX_CONTEXT | RxContext | ) |
◆ RxLowIoIoCtlShellCompletion()
| NTSTATUS NTAPI RxLowIoIoCtlShellCompletion | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 7187 of file rdbss.c.
7189{
7192
7193 PAGED_CODE();
7194
7196
7199
7200 /* Set information and status */
7202 {
7204 }
7205
7207
7209}
Referenced by RxCommonDeviceControl().
◆ RxLowIoLockControlShell()
| NTSTATUS RxLowIoLockControlShell | ( | IN PRX_CONTEXT | RxContext | ) |
Definition at line 7212 of file rdbss.c.
Referenced by RxCommonCleanup().
◆ RxLowIoNotifyChangeDirectoryCompletion()
| NTSTATUS NTAPI RxLowIoNotifyChangeDirectoryCompletion | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 7224 of file rdbss.c.
7226{
7227 PAGED_CODE();
7228
7229 DPRINT("Completing NCD with: %lx, %lx\n", RxContext->IoStatusBlock.Status, RxContext->IoStatusBlock.Information);
7230
7231 /* Just copy back the IO_STATUS to the IRP */
7234
7236}
Referenced by RxNotifyChangeDirectory().
◆ RxLowIoReadShell()
| NTSTATUS RxLowIoReadShell | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 7242 of file rdbss.c.
7244{
7247
7248 PAGED_CODE();
7249
7251
7254 {
7256 }
7257
7258 /* Always update stats for disks */
7260 {
7261 ExInterlockedAddLargeStatistic(&RxContext->RxDeviceObject->NetworkReadBytesRequested, RxContext->LowIoContext.ParamsFor.ReadWrite.ByteCount);
7262 }
7263
7264 /* And forward the read to the mini-rdr */
7267
7269}
NTSTATUS NTAPI RxLowIoReadShellCompletion(PRX_CONTEXT RxContext)
Definition: rdbss.c:7273
LARGE_INTEGER NetworkReadBytesRequested
Definition: rxstruc.h:106
Referenced by RxCommonRead().
◆ RxLowIoReadShellCompletion()
| NTSTATUS NTAPI RxLowIoReadShellCompletion | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 7273 of file rdbss.c.
7275{
7281 PLOWIO_CONTEXT LowIoContext;
7282
7283 PAGED_CODE();
7284
7286
7288 DPRINT("In %p, Status: %lx, Information: %lx\n", RxContext, Status, RxContext->IoStatusBlock.Information);
7289
7292
7293 /* Set IRP information from the RX_CONTEXT status block */
7295
7296 /* Fixup status for paging file if nothing was read */
7297 if (PagingIo)
7298 {
7300 {
7302 }
7303 }
7304
7305 LowIoContext = &RxContext->LowIoContext;
7307
7308 /* Check broken cases that should never happen */
7311 {
7313 {
7316 }
7317 }
7319 {
7321 {
7324 {
7326 }
7327 }
7328
7330 {
7332 }
7333 }
7334
7335 /* Readahead should go through Cc and not finish here */
7337
7338 /* If it's sync, RxCommonRead will finish the work - nothing to do here */
7340 {
7342 }
7343
7346 /* Release lock if required */
7347 if (PagingIo)
7348 {
7350 }
7351 else
7352 {
7353 /* Set FastIo if read was a success */
7355 {
7357 }
7358
7360 {
7361 RxResumeBlockedOperations_Serially(RxContext, &((PFOBX)RxContext->pFobx)->Specific.NamedPipe.ReadSerializationQueue);
7362 }
7363 else
7364 {
7366 }
7367 }
7368
7370 {
7371 UNIMPLEMENTED;
7372 }
7373
7374 /* Final sanity checks */
7378
7380}
@ RXCONTEXT_FLAG4LOWIO_THIS_READ_ENLARGED
Definition: rxcontx.h:335
Referenced by RxLowIoReadShell().
◆ RxLowIoWriteShell()
| NTSTATUS RxLowIoWriteShell | ( | IN PRX_CONTEXT | RxContext | ) |
Definition at line 7386 of file rdbss.c.
7388{
7391
7392 PAGED_CODE();
7393
7395
7397
7400
7401 /* Always update stats for disks */
7403 {
7404 ExInterlockedAddLargeStatistic(&RxContext->RxDeviceObject->NetworkWriteBytesRequested, RxContext->LowIoContext.ParamsFor.ReadWrite.ByteCount);
7405 }
7406
7407 /* And forward the write to the mini-rdr */
7410
7412}
NTSTATUS NTAPI RxLowIoWriteShellCompletion(PRX_CONTEXT RxContext)
Definition: rdbss.c:7416
Referenced by RxCommonWrite().
◆ RxLowIoWriteShellCompletion()
| NTSTATUS NTAPI RxLowIoWriteShellCompletion | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 7416 of file rdbss.c.
7418{
7422 BOOLEAN PagingIo;
7423 PLOWIO_CONTEXT LowIoContext;
7424
7425 PAGED_CODE();
7426
7428
7430 DPRINT("In %p, Status: %lx, Information: %lx\n", RxContext, Status, RxContext->IoStatusBlock.Information);
7431
7433
7434 /* Set IRP information from the RX_CONTEXT status block */
7436
7437 LowIoContext = &RxContext->LowIoContext;
7439
7440 /* Perform a few sanity checks */
7443 {
7445 {
7448 }
7449
7451 }
7452
7455 {
7457 }
7458
7459 /* In case of async call, perform last bits not done in RxCommonWrite */
7461 {
7464
7465 /* We only succeed if we wrote what was asked for */
7466 if (NT_SUCCESS(Status) && !BooleanFlagOn(RxContext->FlagsForLowIo, RXCONTEXT_FLAG4LOWIO_PIPE_OPERATION))
7467 {
7469 }
7470
7471 /* If write succeed, ,also update FILE_OBJECT flags */
7474 if (!PagingIo)
7475 {
7477 }
7478
7479 if (BooleanFlagOn(LowIoContext->ParamsFor.ReadWrite.Flags, LOWIO_READWRITEFLAG_EXTENDING_FILESIZE))
7480 {
7482 }
7483
7484 /* If VDL was extended, fix attributes */
7486 {
7488
7490 Irp->IoStatus.Information;
7492
7494 {
7495 LastOffset = FileSize;
7496 }
7497
7499 }
7500
7501 /* One less outstanding write */
7503 {
7504 PNON_PAGED_FCB NonPagedFcb;
7505
7508 {
7510 -1, &RxStrucSupSpinLock) == 1)
7511 {
7513 }
7514 }
7515 }
7516
7517 /* Release paging resource if acquired */
7519 {
7521 }
7522
7523 /* Resume blocked operations for pipes */
7525 {
7526 RxResumeBlockedOperations_Serially(RxContext,
7528 }
7529 else
7530 {
7531 /* And release FCB only for files */
7533 {
7535 }
7536 }
7537
7538 /* Final sanity checks */
7540 ASSERT((Status != STATUS_SUCCESS) || (Irp->IoStatus.Information <= Stack->Parameters.Write.Length));
7542
7544 {
7545 UNIMPLEMENTED;
7546 }
7547 }
7548
7550}
@ RXCONTEXT_FLAG4LOWIO_THIS_IO_BUFFERED
Definition: rxcontx.h:336
Definition: fatstruc.h:719
Referenced by RxLowIoWriteShell().
◆ RxNewMapUserBuffer()
| PVOID RxNewMapUserBuffer | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 5775 of file rxce.c.
5777{
5779
5780 PAGED_CODE();
5781
5784 {
5786 }
5787
5789}
#define MmGetSystemAddressForMdlSafe(_Mdl, _Priority)
Referenced by RxCommonRead(), RxCommonWrite(), RxLowIoSubmit(), and RxQueryDirectory().
◆ RxNotifyChangeDirectory()
| NTSTATUS RxNotifyChangeDirectory | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 7556 of file rdbss.c.
7558{
7562
7563 PAGED_CODE();
7564
7565 /* The IRP can abviously wait */
7567
7568 /* Initialize its lowio */
7570
7571 _SEH2_TRY
7572 {
7573 /* Lock user buffer */
7576
7577 /* Copy parameters from IO_STACK */
7578 RxContext->LowIoContext.ParamsFor.NotifyChangeDirectory.WatchTree = BooleanFlagOn(Stack->Flags, SL_WATCH_TREE);
7579 RxContext->LowIoContext.ParamsFor.NotifyChangeDirectory.CompletionFilter = Stack->Parameters.NotifyDirectory.CompletionFilter;
7580 RxContext->LowIoContext.ParamsFor.NotifyChangeDirectory.NotificationBufferLength = Stack->Parameters.NotifyDirectory.Length;
7581
7582 /* If we have an associated MDL */
7585 {
7586 /* Then, call mini-rdr */
7587 RxContext->LowIoContext.ParamsFor.NotifyChangeDirectory.pNotificationBuffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
7589 {
7591 }
7592 else
7593 {
7595 }
7596 }
7597 else
7598 {
7600 }
7601 }
7602 _SEH2_FINALLY
7603 {
7604 /* All correct */
7605 }
7606 _SEH2_END;
7607
7609}
NTSTATUS NTAPI RxLowIoNotifyChangeDirectoryCompletion(PRX_CONTEXT RxContext)
Definition: rdbss.c:7224
VOID RxLockUserBuffer(_In_ PRX_CONTEXT RxContext, _In_ LOCK_OPERATION Operation, _In_ ULONG BufferLength)
struct _LOWIO_CONTEXT::@2065::@2068 NotifyChangeDirectory
Referenced by RxCommonDirectoryControl().
◆ RxpCancelRoutine()
Definition at line 7616 of file rdbss.c.
7618{
7619 PRX_CONTEXT RxContext;
7620
7621 PAGED_CODE();
7622
7623 RxContext = Context;
7624
7625 /* First, notify mini-rdr about cancellation */
7627 {
7628 RxContext->MRxCancelRoutine(RxContext);
7629 }
7630 /* If we didn't find in overflow queue, try in blocking operations */
7632 {
7633 RxCancelBlockingOperation(RxContext);
7634 }
7635
7636 /* And delete the context */
7637 RxDereferenceAndDeleteRxContext_Real(RxContext);
7638}
BOOLEAN RxCancelOperationInOverflowQueue(PRX_CONTEXT RxContext)
Definition: rdbss.c:1139
VOID RxCancelBlockingOperation(_Inout_ PRX_CONTEXT RxContext)
Referenced by RxCancelRoutine().
◆ RxPostStackOverflowRead()
| NTSTATUS RxPostStackOverflowRead | ( | IN PRX_CONTEXT | RxContext | ) |
Definition at line 7641 of file rdbss.c.
Referenced by RxFsdCommonDispatch().
◆ RxpPrepareCreateContextForReuse()
| VOID RxpPrepareCreateContextForReuse | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 7654 of file rdbss.c.
7656{
7657 /* Reuse can only happen for open operations (STATUS_RETRY) */
7659
7660 /* Release the FCB if it was acquired */
7662 {
7665 }
7666
7667 /* Free the canonical name */
7668 RxFreeCanonicalNameBuffer(RxContext);
7669
7670 /* If we have a VNetRoot associated */
7672 {
7673 /* Remove our link and thus, dereference the VNetRoot */
7676 {
7679 }
7681 }
7682
7684}
VOID RxpReleasePrefixTableLock(_In_ PRX_PREFIX_TABLE pTable, _In_ BOOLEAN ProcessBufferingStateChangeRequests)
BOOLEAN RxpAcquirePrefixTableLockShared(_In_ PRX_PREFIX_TABLE pTable, _In_ BOOLEAN Wait, _In_ BOOLEAN ProcessBufferingStateChangeRequests)
Referenced by RxCommonCreate(), and RxPrefixClaim().
◆ RxpQueryInfoMiniRdr()
| NTSTATUS RxpQueryInfoMiniRdr | ( | PRX_CONTEXT | RxContext, |
| FILE_INFORMATION_CLASS | FileInfoClass, | ||
| PVOID | Buffer | ||
| ) |
Definition at line 7690 of file rdbss.c.
7694{
7697
7699
7700 /* Set the RX_CONTEXT */
7701 RxContext->Info.FileInformationClass = FileInfoClass;
7703
7704 /* Pass down */
7706
7708}
Referenced by RxCommonQueryInformation(), RxQueryBasicInfo(), and RxQueryStandardInfo().
◆ RxPrefixClaim()
| NTSTATUS RxPrefixClaim | ( | IN PRX_CONTEXT | RxContext | ) |
Definition at line 7714 of file rdbss.c.
7716{
7719 NET_ROOT_TYPE NetRootType;
7721
7722 PAGED_CODE();
7723
7724 Irp = RxContext->CurrentIrp;
7725
7726 /* This has to come from MUP */
7728 {
7730 }
7731
7733 {
7734 PQUERY_PATH_REQUEST QueryRequest;
7735
7736 /* Get parameters */
7737 QueryRequest = RxContext->CurrentIrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
7738
7739 /* Don't overflow allocation */
7741 {
7743 }
7744
7745 /* Forcefully rewrite IRP MJ */
7746 RxContext->MajorFunction = IRP_MJ_CREATE;
7747
7748 /* Fake canon name */
7749 RxContext->PrefixClaim.SuppliedPathName.Buffer = RxAllocatePoolWithTag(NonPagedPool, QueryRequest->PathNameLength, RX_MISC_POOLTAG);
7751 {
7753 goto Leave;
7754 }
7755
7756 /* Copy the prefix to look for */
7757 RtlCopyMemory(RxContext->PrefixClaim.SuppliedPathName.Buffer, &QueryRequest->FilePathName[0], QueryRequest->PathNameLength);
7758 RxContext->PrefixClaim.SuppliedPathName.Length = QueryRequest->PathNameLength;
7759 RxContext->PrefixClaim.SuppliedPathName.MaximumLength = QueryRequest->PathNameLength;
7760
7761 /* Zero the create parameters */
7762 RtlZeroMemory(&RxContext->Create,
7763 FIELD_OFFSET(RX_CONTEXT, AlsoCanonicalNameBuffer) - FIELD_OFFSET(RX_CONTEXT, Create.NtCreateParameters));
7764 RxContext->Create.ThisIsATreeConnectOpen = TRUE;
7765 RxContext->Create.NtCreateParameters.SecurityContext = QueryRequest->SecurityContext;
7766 }
7767 else
7768 {
7769 /* If not devcontrol, it comes from open, name was already copied */
7772 }
7773
7774 /* Canonilize name */
7775 NetRootType = NET_ROOT_WILD;
7776 RtlInitEmptyUnicodeString(&CanonicalName, NULL, 0);
7777 FileName.Length = RxContext->PrefixClaim.SuppliedPathName.Length;
7778 FileName.MaximumLength = RxContext->PrefixClaim.SuppliedPathName.MaximumLength;
7779 FileName.Buffer = RxContext->PrefixClaim.SuppliedPathName.Buffer;
7780 NetRootName.Length = RxContext->PrefixClaim.SuppliedPathName.Length;
7781 NetRootName.MaximumLength = RxContext->PrefixClaim.SuppliedPathName.MaximumLength;
7782 NetRootName.Buffer = RxContext->PrefixClaim.SuppliedPathName.Buffer;
7784 /* It went fine, attempt to establish a connection (that way we know whether the prefix is accepted) */
7786 {
7787 Status = RxFindOrConstructVirtualNetRoot(RxContext, &CanonicalName, NetRootType, &NetRootName);
7788 }
7790 {
7792 }
7793 /* Reply to MUP */
7795 {
7796 PQUERY_PATH_RESPONSE QueryResponse;
7797
7798 /* We accept the length that was canon (minus netroot) */
7799 QueryResponse = RxContext->CurrentIrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
7800 QueryResponse->LengthAccepted = RxContext->PrefixClaim.SuppliedPathName.Length - NetRootName.Length;
7801 }
7802
7803Leave:
7804 /* If we reach that point with MJ, reset everything and make IRP being a device control */
7806 {
7808 {
7809 RxFreePoolWithTag(RxContext->PrefixClaim.SuppliedPathName.Buffer, RX_MISC_POOLTAG);
7810 }
7811
7812 RxpPrepareCreateContextForReuse(RxContext);
7813
7814 RxContext->MajorFunction = IRP_MJ_DEVICE_CONTROL;
7815 }
7816
7818}
Definition: ntifs.template.h:1262
PIO_SECURITY_CONTEXT SecurityContext
Definition: ntifs.template.h:1264
Definition: ntifs.template.h:1277
Referenced by RxCommonDevFCBIoCtl().
◆ RxPrepareToReparseSymbolicLink()
| NTSTATUS NTAPI RxPrepareToReparseSymbolicLink | ( | PRX_CONTEXT | RxContext, |
| BOOLEAN | SymbolicLinkEmbeddedInOldPath, | ||
| PUNICODE_STRING | NewPath, | ||
| BOOLEAN | NewPathIsAbsolute, | ||
| PBOOLEAN | ReparseRequired | ||
| ) |
Definition at line 7825 of file rdbss.c.
7831{
7832 PWSTR NewBuffer;
7835
7836 /* Assume no reparse is required first */
7837 *ReparseRequired = FALSE;
7838
7839 /* Only supported for IRP_MJ_CREATE */
7841 {
7843 }
7844
7845 /* If symbolic link is not embedded, and DELETE is specified, fail */
7846 if (!SymbolicLinkEmbeddedInOldPath)
7847 {
7848 /* Excepted if DELETE is the only flag specified, then, open has to succeed
7849 * See: https://msdn.microsoft.com/en-us/library/windows/hardware/ff554649(v=vs.85).aspx (remarks)
7850 */
7853 {
7855 }
7856 }
7857
7858 /* At that point, assume reparse will be required */
7859 *ReparseRequired = TRUE;
7860
7861 /* If new path isn't absolute, it's up to us to make it absolute */
7862 if (!NewPathIsAbsolute)
7863 {
7864 /* The prefix will be \Device\Mup */
7867 RX_MISC_POOLTAG);
7869 {
7871 }
7872
7873 /* Copy data for the new path */
7877 }
7878 /* Otherwise, use caller path as it */
7879 else
7880 {
7882 NewBuffer = NewPath->Buffer;
7883 }
7884
7885 /* Get the FILE_OBJECT we'll modify */
7887
7888 /* Free old path first */
7890 /* And setup new one */
7893 FileObject->FileName.Buffer = NewBuffer;
7894
7895 /* And set reparse flag */
7897
7898 /* Done! */
7900}
◆ RxPrePostIrp()
Definition at line 7906 of file rdbss.c.
7909{
7913
7914 /* NULL IRP is no option */
7916 {
7917 return;
7918 }
7919
7920 /* Check whether preparation was really needed */
7922 {
7923 return;
7924 }
7925 /* Mark the context as prepared */
7927
7928 /* Just lock the user buffer, with the correct length, depending on the MJ */
7932 {
7934 {
7936 {
7938 }
7940 }
7941 }
7942 else
7943 {
7944 if ((RxContext->MajorFunction == IRP_MJ_DIRECTORY_CONTROL && RxContext->MinorFunction == IRP_MN_QUERY_DIRECTORY) ||
7946 {
7949 }
7951 {
7953 }
7954 }
7955
7956 /* As it will be posted (async), mark the IRP pending */
7958}
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:127
enum _LOCK_OPERATION LOCK_OPERATION
Referenced by RxCommonWrite(), and RxFsdPostRequest().
◆ RxpSetInfoMiniRdr()
| NTSTATUS RxpSetInfoMiniRdr | ( | PRX_CONTEXT | RxContext, |
| FILE_INFORMATION_CLASS | Class | ||
| ) |
Definition at line 7964 of file rdbss.c.
7967{
7970
7971 /* Initialize parameters in RX_CONTEXT */
7975
7976 /* And call mini-rdr */
7979
7981}
struct _IO_STACK_LOCATION::@3978::@3988 SetFile
union _IRP::@1566 AssociatedIrp
Referenced by RxSetBasicInfo(), RxSetDispositionInfo(), and RxSetRenameInfo().
◆ RxpUnregisterMinirdr()
| VOID NTAPI RxpUnregisterMinirdr | ( | IN PRDBSS_DEVICE_OBJECT | RxDeviceObject | ) |
◆ RxPurgeNetFcb()
| VOID RxPurgeNetFcb | ( | PFCB | Fcb, |
| PRX_CONTEXT | LocalContext | ||
| ) |
Definition at line 7995 of file rdbss.c.
7998{
8000
8001 PAGED_CODE();
8002
8003 /* First, flush */
8005
8006 /* And force close */
8011}
BOOLEAN NTAPI MmForceSectionClosed(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN BOOLEAN DelayClose)
Definition: section.c:3042
Referenced by RxCloseAssociatedSrvOpen().
◆ RxQueryAlternateNameInfo()
| NTSTATUS RxQueryAlternateNameInfo | ( | PRX_CONTEXT | RxContext, |
| PFILE_NAME_INFORMATION | AltNameInfo | ||
| ) |
Definition at line 8014 of file rdbss.c.
Referenced by RxCommonQueryInformation().
◆ RxQueryBasicInfo()
| NTSTATUS RxQueryBasicInfo | ( | PRX_CONTEXT | RxContext, |
| PFILE_BASIC_INFORMATION | BasicInfo | ||
| ) |
Definition at line 8026 of file rdbss.c.
Referenced by RxCommonQueryInformation().
◆ RxQueryCompressedInfo()
| NTSTATUS RxQueryCompressedInfo | ( | PRX_CONTEXT | RxContext, |
| PFILE_COMPRESSION_INFORMATION | CompressionInfo | ||
| ) |
Definition at line 8040 of file rdbss.c.
Referenced by RxCommonQueryInformation().
◆ RxQueryDirectory()
| NTSTATUS RxQueryDirectory | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 8052 of file rdbss.c.
8054{
8057 PFOBX Fobx;
8060 BOOLEAN LockNotGranted;
8064 FILE_INFORMATION_CLASS FileInfoClass;
8065
8066 PAGED_CODE();
8067
8069
8070 /* Get parameters */
8074 FileInfoClass = Stack->Parameters.QueryDirectory.FileInformationClass;
8077 FileName, FileInfoClass);
8078
8081 FileIndex = Stack->Parameters.QueryDirectory.FileIndex;
8083
8085 {
8087 }
8088
8089 /* No FOBX: not a standard file/directory */
8092 {
8094 }
8095
8096 /* We can only deal with a disk */
8099 {
8102 }
8103
8104 /* Setup RX_CONTEXT related fields */
8105 RxContext->QueryDirectory.FileIndex = FileIndex;
8109 RxContext->QueryDirectory.InitialQuery = (Fobx->UnicodeQueryTemplate.Buffer == NULL) && !BooleanFlagOn(Fobx->Flags, FOBX_FLAG_MATCH_ALL);
8110
8111 /* We don't support (yet?) a specific index being set */
8113 {
8115 }
8116
8117 /* Try to lock FCB */
8118 LockNotGranted = TRUE;
8120 {
8123 {
8125 {
8127 }
8128
8130 {
8133 }
8134
8135 LockNotGranted = FALSE;
8136 }
8137 }
8138 else
8139 {
8142 {
8144 {
8146 }
8147
8148 LockNotGranted = FALSE;
8149 }
8150 }
8151
8152 /* If it failed, post request */
8153 if (LockNotGranted)
8154 {
8156 }
8157
8158 /* This cannot be done on a orphaned directory */
8160 {
8163 }
8164
8165 _SEH2_TRY
8166 {
8167 /* Set index */
8169 {
8170 RxContext->QueryDirectory.FileIndex = 0;
8171 }
8172
8173 /* Assume success */
8175 /* If initial query, prepare FOBX */
8177 {
8178 /* We cannot have a template already! */
8180
8181 /* If we have a file name and a correct one, duplicate it in the FOBX */
8186 {
8188
8189 Fobx->UnicodeQueryTemplate.Buffer = RxAllocatePoolWithTag(PagedPool, FileName->Length, RX_DIRCTL_POOLTAG);
8191 {
8192 /* UNICODE_STRING; length has to be even */
8194 {
8196 RxFreePoolWithTag(Fobx->UnicodeQueryTemplate.Buffer, RX_DIRCTL_POOLTAG);
8197 }
8198 else
8199 {
8200 Fobx->UnicodeQueryTemplate.Length = FileName->Length;
8201 Fobx->UnicodeQueryTemplate.MaximumLength = FileName->Length;
8203
8205 }
8206 }
8207 else
8208 {
8210 }
8211 }
8212 /* No name specified, or a match all wildcard? Match everything */
8213 else
8214 {
8216
8217 Fobx->UnicodeQueryTemplate.Buffer = &RxStarForTemplate;
8220
8222 }
8223
8224 /* No need for exclusive any longer */
8226 {
8228 }
8229 }
8230
8231 /* Lock user buffer and forward to mini-rdr */
8233 {
8235 RxContext->Info.FileInformationClass = FileInfoClass;
8238
8240 {
8242 }
8243
8244 /* Post if mini-rdr asks to */
8246 {
8247 RxFsdPostRequest(RxContext);
8248 }
8249 else
8250 {
8252 }
8253 }
8254 }
8255 _SEH2_FINALLY
8256 {
8258 }
8259 _SEH2_END;
8260
8262}
struct _IO_STACK_LOCATION::@3978::@3984 QueryDirectory
struct _RX_CONTEXT::@2148::@2161 QueryDirectory
Referenced by RxCommonDirectoryControl().
◆ RxQueryEaInfo()
| NTSTATUS RxQueryEaInfo | ( | PRX_CONTEXT | RxContext, |
| PFILE_EA_INFORMATION | EaInfo | ||
| ) |
Definition at line 8265 of file rdbss.c.
Referenced by RxCommonQueryInformation().
◆ RxQueryInternalInfo()
| NTSTATUS RxQueryInternalInfo | ( | PRX_CONTEXT | RxContext, |
| PFILE_INTERNAL_INFORMATION | InternalInfo | ||
| ) |
Definition at line 8274 of file rdbss.c.
Referenced by RxCommonQueryInformation().
◆ RxQueryNameInfo()
| NTSTATUS RxQueryNameInfo | ( | PRX_CONTEXT | RxContext, |
| PFILE_NAME_INFORMATION | NameInfo | ||
| ) |
Definition at line 8286 of file rdbss.c.
8289{
8291 PFOBX Fobx;
8292 PAGED_CODE();
8293
8295
8296 /* Check we can at least copy name size */
8298 {
8300 RxContext->Info.Length = 0;
8302 }
8303
8305
8308 /* Get the UNC name */
8311
8312 /* If RxConjureOriginalName returned a negative len (-1) then output buffer
8313 * was too small, return the appropriate length & status.
8314 */
8316 {
8318 RxContext->Info.Length = 0;
8320 }
8321
8322#if 1 // CORE-13938, rfb: please note I replaced 0 with 1 here
8325 {
8329 }
8330#endif
8331
8332 /* All correct */
8334}
VOID RxConjureOriginalName(PFCB Fcb, PFOBX Fobx, PULONG ActualNameLength, PWCHAR OriginalName, PLONG LengthRemaining, RX_NAME_CONJURING_METHODS NameConjuringMethod)
Definition: rdbss.c:4911
Definition: winternl.h:649
Referenced by RxCommonQueryInformation().
◆ RxQueryPipeInfo()
| NTSTATUS RxQueryPipeInfo | ( | PRX_CONTEXT | RxContext, |
| PFILE_PIPE_INFORMATION | PipeInfo | ||
| ) |
Definition at line 8337 of file rdbss.c.
Referenced by RxCommonQueryInformation().
◆ RxQueryPositionInfo()
| NTSTATUS RxQueryPositionInfo | ( | PRX_CONTEXT | RxContext, |
| PFILE_POSITION_INFORMATION | PositionInfo | ||
| ) |
Definition at line 8346 of file rdbss.c.
Referenced by RxCommonQueryInformation().
◆ RxQueryStandardInfo()
| NTSTATUS RxQueryStandardInfo | ( | PRX_CONTEXT | RxContext, |
| PFILE_STANDARD_INFORMATION | StandardInfo | ||
| ) |
Definition at line 8358 of file rdbss.c.
8361{
8363 PFOBX Fobx;
8365
8366 PAGED_CODE();
8367
8369
8370 /* Zero output buffer */
8372
8375 /* If not a standard file type, or opened for backup, immediately forward to mini-rdr */
8376 if ((NodeType(Fcb) != RDBSS_NTC_STORAGE_TYPE_DIRECTORY && NodeType(Fcb) != RDBSS_NTC_STORAGE_TYPE_FILE) ||
8378 {
8380 }
8381
8382 /* Otherwise, fill what we can already */
8388 {
8389 StandardInfo->NumberOfLinks = 1;
8390 }
8391
8393 {
8396 }
8397
8398 /* If we are asked to forcefully forward to mini-rdr or if size isn't cached, do it */
8399 if (RxForceQFIPassThrough || !BooleanFlagOn(Fcb->FcbState, FCB_STATE_FILESIZECACHEING_ENABLED))
8400 {
8402 }
8403 else
8404 {
8406 }
8407
8409}
Referenced by RxCommonQueryInformation().
◆ RxReadRegistryParameters()
Definition at line 8416 of file rdbss.c.
8418{
8425 PKEY_VALUE_PARTIAL_INFORMATION PartialInfo;
8426
8427 PAGED_CODE();
8428
8429 RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\LanmanWorkStation\\Parameters");
8431 Status = ZwOpenKey(&KeyHandle, READ_CONTROL | KEY_NOTIFY | KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE, &ObjectAttributes);
8433 {
8434 return;
8435 }
8436
8439 Status = ZwQueryValueKey(KeyHandle, &ParamName, KeyValuePartialInformation, PartialInfo, sizeof(Buffer), &ResultLength);
8441 {
8443 }
8444
8446 Status = ZwQueryValueKey(KeyHandle, &ParamName, KeyValuePartialInformation, PartialInfo, sizeof(Buffer), &ResultLength);
8448 {
8450
8451 if (Granularity > 16)
8452 {
8453 Granularity = 16;
8454 }
8455
8457 }
8458
8460 Status = ZwQueryValueKey(KeyHandle, &ParamName, KeyValuePartialInformation, PartialInfo, sizeof(Buffer), &ResultLength);
8462 {
8464 }
8465
8467}
BOOLEAN DisableByteRangeLockingOnReadOnlyFiles
Definition: rdbss.c:532
Referenced by RxDriverEntry().
◆ RxRegisterMinirdr()
| NTSTATUS NTAPI RxRegisterMinirdr | ( | OUT PRDBSS_DEVICE_OBJECT * | DeviceObject, |
| IN OUT PDRIVER_OBJECT | DriverObject, | ||
| IN PMINIRDR_DISPATCH | MrdrDispatch, | ||
| IN ULONG | Controls, | ||
| IN PUNICODE_STRING | DeviceName, | ||
| IN ULONG | DeviceExtensionSize, | ||
| IN DEVICE_TYPE | DeviceType, | ||
| IN ULONG | DeviceCharacteristics | ||
| ) |
Definition at line 8474 of file rdbss.c.
8483{
8485 PRDBSS_DEVICE_OBJECT RDBSSDevice;
8486
8487 PAGED_CODE();
8488
8490 {
8492 }
8493
8494 /* Create device object with provided parameters */
8497 DeviceName,
8498 DeviceType,
8499 DeviceCharacteristics,
8500 FALSE,
8501 (PDEVICE_OBJECT *)&RDBSSDevice);
8503 {
8505 }
8506
8508 {
8510 }
8511
8512 /* Initialize our DO extension */
8514 ++RxFileSystemDeviceObject->ReferenceCount;
8515 *DeviceObject = RDBSSDevice;
8517 RDBSSDevice->Dispatch = MrdrDispatch;
8518 RDBSSDevice->RegistrationControls = Controls;
8520 RDBSSDevice->RegisterUncProvider = !BooleanFlagOn(Controls, RX_REGISTERMINI_FLAG_DONT_PROVIDE_UNCS);
8521 RDBSSDevice->RegisterMailSlotProvider = !BooleanFlagOn(Controls, RX_REGISTERMINI_FLAG_DONT_PROVIDE_MAILSLOTS);
8527
8528 DPRINT("Registered MiniRdr %wZ (prio: %x)\n", DeviceName, RDBSSDevice->NetworkProviderPriority);
8529
8533
8534 /* Unless mini-rdr explicitly asked not to, initialize dispatch table */
8536 {
8538 }
8539
8540 /* Unless mini-rdr explicitly asked not to, initialize prefix scavenger */
8542 {
8543 LARGE_INTEGER ScavengerTimeLimit;
8544
8548 ScavengerTimeLimit.QuadPart = MrdrDispatch->ScavengerTimeout * 10000000LL;
8551 }
8552
8554
8556}
#define RX_REGISTERMINI_FLAG_DONT_PROVIDE_MAILSLOTS
Definition: mrx.h:10
#define RX_REGISTERMINI_FLAG_DONT_INIT_DRIVER_DISPATCH
Definition: mrx.h:11
#define RX_REGISTERMINI_FLAG_DONT_PROVIDE_UNCS
Definition: mrx.h:9
#define RX_REGISTERMINI_FLAG_DONT_INIT_PREFIX_N_SCAVENGER
Definition: mrx.h:12
NTSTATUS NTAPI IoCreateDevice(IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1031
VOID RxInitializePrefixTable(_Inout_ PRX_PREFIX_TABLE ThisTable, _In_opt_ ULONG TableSize, _In_ BOOLEAN CaseInsensitiveMatch)
ULONG RxGetNetworkProviderPriority(PUNICODE_STRING DeviceName)
Definition: rdbss.c:6683
VOID RxInitializeMinirdrDispatchTable(IN PDRIVER_OBJECT DriverObject)
Definition: rdbss.c:6953
#define RxInitializeRdbssScavenger(Scavenger, ScavengerTimeLimit)
Definition: scavengr.h:84
Definition: env_spec_w32.h:413
BOOLEAN RegisterMailSlotProvider
Definition: rxstruc.h:94
RDBSS_SCAVENGER RdbssScavengerInDeviceObject
Definition: rxstruc.h:130
RX_PREFIX_TABLE RxNetNameTableInDeviceObject
Definition: rxstruc.h:128
PKEVENT pAsynchronousRequestsCompletionEvent
Definition: rxstruc.h:124
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3275
◆ RxReleaseFileForNtCreateSection()
| VOID NTAPI RxReleaseFileForNtCreateSection | ( | PFILE_OBJECT | FileObject | ) |
Definition at line 7578 of file rxce.c.
Referenced by RxInitializeDispatchVectors().
◆ RxReleaseForCcFlush()
| NTSTATUS NTAPI RxReleaseForCcFlush | ( | PFILE_OBJECT | FileObject, |
| PDEVICE_OBJECT | DeviceObject | ||
| ) |
Definition at line 7586 of file rxce.c.
Referenced by RxInitializeDispatchVectors().
◆ RxRemoveFromTopLevelIrpAllocatedContextsList()
| VOID RxRemoveFromTopLevelIrpAllocatedContextsList | ( | PRX_TOPLEVELIRP_CONTEXT | TopLevelContext | ) |
Definition at line 8562 of file rdbss.c.
8564{
8566
8567 /* Make sure this is a TLC and that it was allocated (otherwise, it is not in the list */
8570
8574}
Referenced by RxUnwindTopLevelIrp().
◆ RxRemoveOverflowEntry()
| PRX_CONTEXT RxRemoveOverflowEntry | ( | PRDBSS_DEVICE_OBJECT | DeviceObject, |
| WORK_QUEUE_TYPE | Queue | ||
| ) |
Definition at line 8580 of file rdbss.c.
8583{
8586
8589 {
8590 /* No entries left, nothing to return */
8593 }
8594 else
8595 {
8597
8598 /* Decrement count */
8600
8601 /* Return head */
8604 ClearFlag(Context->Flags, (RX_CONTEXT_FLAG_FSP_DELAYED_OVERFLOW_QUEUE | RX_CONTEXT_FLAG_FSP_CRITICAL_OVERFLOW_QUEUE));
8606 }
8608
8610}
Referenced by RxFspDispatch().
◆ RxRemoveShareAccessPerSrvOpens()
Definition at line 8635 of file rdbss.c.
8637{
8641 BOOLEAN DeleteAccess;
8642
8643 PAGED_CODE();
8644
8645 /* Get access that were granted to SRV_OPEN */
8646 DesiredAccess = SrvOpen->DesiredAccess;
8650
8651 /* If any, drop them */
8653 {
8654 BOOLEAN SharedRead;
8655 BOOLEAN SharedWrite;
8656 BOOLEAN SharedDelete;
8659
8661 DesiredShareAccess = SrvOpen->ShareAccess;
8662
8665 ShareAccess->Deleters -= DeleteAccess;
8666
8667 ShareAccess->OpenCount--;
8668
8672 ShareAccess->SharedRead -= SharedRead;
8673 ShareAccess->SharedWrite -= SharedWrite;
8674 ShareAccess->SharedDelete -= SharedDelete;
8675 }
8676}
Referenced by RxCloseAssociatedSrvOpen().
◆ RxSearchForCollapsibleOpen()
| NTSTATUS RxSearchForCollapsibleOpen | ( | PRX_CONTEXT | RxContext, |
| ACCESS_MASK | DesiredAccess, | ||
| ULONG | ShareAccess | ||
| ) |
Definition at line 8679 of file rdbss.c.
8683{
8686 PLIST_ENTRY ListEntry;
8687 BOOLEAN ShouldTry, Purged, Scavenged;
8688
8689 PAGED_CODE();
8690
8692
8694
8695 /* If we're asked to open for backup, don't allow SRV_OPEN reuse */
8696 if (BooleanFlagOn(RxContext->Create.NtCreateParameters.CreateOptions, FILE_OPEN_FOR_BACKUP_INTENT))
8697 {
8699
8702
8704 }
8705
8706 /* If basic open, ask the mini-rdr if we should try to collapse */
8709 {
8710 ShouldTry = TRUE;
8711
8713 {
8716
8718 }
8719 }
8720 else
8721 {
8722 ShouldTry = FALSE;
8723 }
8724
8726 {
8727 ShouldTry = FALSE;
8728 }
8729
8730 /* If we shouldn't try, ask the caller to allocate a new SRV_OPEN */
8731 if (!ShouldTry)
8732 {
8734 {
8736 }
8737
8739
8742
8744 }
8745
8746 /* Only collapse for matching NET_ROOT & disks */
8749 {
8751 }
8752
8753 Purged = FALSE;
8754 Scavenged = FALSE;
8756TryAgain:
8757 /* Browse all our SRV_OPEN to find the matching one */
8759 ListEntry != &Fcb->SrvOpenList;
8760 ListEntry = ListEntry->Flink)
8761 {
8762 PSRV_OPEN SrvOpen;
8763
8765 /* Not the same VNET_ROOT, move to the next one */
8767 {
8769 continue;
8770 }
8771
8772 /* Is there a sharing violation? */
8774 BooleanFlagOn(SrvOpen->Flags, (SRVOPEN_FLAG_CLOSED | SRVOPEN_FLAG_COLLAPSING_DISABLED | SRVOPEN_FLAG_FILE_DELETED | SRVOPEN_FLAG_FILE_RENAMED)))
8775 {
8777 {
8779 continue;
8780 }
8781
8782 /* Check against the SRV_OPEN */
8785 {
8786 break;
8787 }
8788 }
8789 else
8790 {
8791 /* Don't allow collaspse for reparse point opening */
8792 if (BooleanFlagOn(RxContext->Create.NtCreateParameters.CreateOptions ^ SrvOpen->CreateOptions, FILE_OPEN_REPARSE_POINT))
8793 {
8794 Purged = TRUE;
8795 Scavenged = TRUE;
8797 break;
8798 }
8799
8800 /* Not readonly? Or bytereange lock disabled? Try to collapse! */
8801 if (DisableByteRangeLockingOnReadOnlyFiles || !BooleanFlagOn(SrvOpen->pFcb->Attributes, FILE_ATTRIBUTE_READONLY))
8802 {
8804
8807 {
8808 /* Is close delayed - great reuse*/
8810 {
8814 }
8815
8817 }
8818
8820 break;
8821 }
8822 }
8823 }
8824 /* We browse the whole list and didn't find any matching? NOT_FOUND */
8826 {
8828 }
8829
8830 /* Only required access: read attributes? Don't reuse */
8832 {
8834 }
8835
8836 /* Not found? Scavenge and retry to look for collaspile SRV_OPEN */
8837 if (!Scavenged)
8838 {
8840 Scavenged = TRUE;
8843 }
8844
8845 /* Not found? Purgeable? Purge and retry to look for collaspile SRV_OPEN */
8847 {
8849 Purged = TRUE;
8851 }
8852
8853 /* If sharing violation, keep track of it */
8855 {
8857 }
8858
8861}
NTSTATUS RxCheckShareAccessPerSrvOpens(IN PFCB Fcb, IN ACCESS_MASK DesiredAccess, IN ULONG DesiredShareAccess)
Definition: rdbss.c:1477
PMRX_CALLDOWN MRxShouldTryToCollapseThisOpen
Definition: mrx.h:353
Referenced by RxCollapseOrCreateSrvOpen().
◆ RxSetAllocationInfo()
| NTSTATUS RxSetAllocationInfo | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 8864 of file rdbss.c.
Referenced by RxCommonSetInformation().
◆ RxSetBasicInfo()
| NTSTATUS RxSetBasicInfo | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 8875 of file rdbss.c.
8877{
8879
8880 PAGED_CODE();
8881
8882#define FILE_ATTRIBUTE_VOLUME 0x8
8883#define VALID_FILE_ATTRIBUTES ( \
8884 FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | \
8885 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_VOLUME | \
8886 FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_DEVICE | \
8887 FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_SPARSE_FILE | \
8888 FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_COMPRESSED | \
8889 FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED | \
8890 FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_INTEGRITY_STREAM)
8891#define VALID_DIR_ATTRIBUTES (VALID_FILE_ATTRIBUTES | FILE_ATTRIBUTE_DIRECTORY)
8892
8893 /* First of all, call the mini-rdr */
8895 /* If it succeed, perform last bits */
8897 {
8900 PFOBX Fobx;
8903 PFILE_BASIC_INFORMATION BasicInfo;
8904
8908 BasicInfo = Irp->AssociatedIrp.SystemBuffer;
8910
8911 /* If caller provided flags, handle the change */
8914 {
8915 /* Clean our flags first, with only stuff we support */
8917 {
8919 }
8920 else
8921 {
8923 }
8924
8925 /* Handle the temporary mark (set/unset depending on caller) */
8927 {
8930 }
8931 else
8932 {
8935 }
8936
8937 /* And set new attributes */
8938 Fcb->Attributes = CleanAttr;
8939 }
8940
8941 /* If caller provided a creation time, set it */
8943 {
8946 }
8947
8948 /* If caller provided a last access time, set it */
8950 {
8953 }
8954
8955 /* If caller provided a last write time, set it */
8957 {
8960 }
8961
8962 /* If caller provided a last change time, set it */
8964 {
8967 }
8968 }
8969
8970 /* Done */
8972}
#define VALID_FILE_ATTRIBUTES
#define VALID_DIR_ATTRIBUTES
NTSTATUS RxpSetInfoMiniRdr(PRX_CONTEXT RxContext, FILE_INFORMATION_CLASS Class)
Definition: rdbss.c:7964
_Must_inspect_result_ _In_ WDFDMAENABLER _In_ _In_opt_ PWDF_OBJECT_ATTRIBUTES Attributes
Definition: wdfcommonbuffer.h:97
Referenced by RxCommonSetInformation().
◆ RxSetDispositionInfo()
| NTSTATUS RxSetDispositionInfo | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 8978 of file rdbss.c.
8980{
8982
8983 PAGED_CODE();
8984
8985 /* First, make the mini-rdr work! */
8987 /* If it succeed, we'll keep track of the change */
8989 {
8992 PFILE_DISPOSITION_INFORMATION FileDispo;
8993
8997 /* Caller asks for deletion: mark as delete on close */
8999 {
9002 }
9003 /* Otherwise, clear it */
9004 else
9005 {
9008 }
9009
9010 /* Sanitize output */
9012 }
9013
9015}
Referenced by RxCommonSetInformation().
◆ RxSetEndOfFileInfo()
| NTSTATUS RxSetEndOfFileInfo | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 9018 of file rdbss.c.
Referenced by RxCommonSetInformation().
◆ RxSetPipeInfo()
| NTSTATUS RxSetPipeInfo | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 9026 of file rdbss.c.
Referenced by RxCommonSetInformation().
◆ RxSetPositionInfo()
| NTSTATUS RxSetPositionInfo | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 9034 of file rdbss.c.
Referenced by RxCommonSetInformation().
◆ RxSetRenameInfo()
| NTSTATUS RxSetRenameInfo | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 9045 of file rdbss.c.
9047{
9052 PFILE_RENAME_INFORMATION RenameInfo, UserInfo;
9053
9054 PAGED_CODE();
9055
9057
9059 DPRINT("FO: %p, Replace: %d\n", Stack->Parameters.SetFile.FileObject, Stack->Parameters.SetFile.ReplaceIfExists);
9060
9061 /* If there's no FO, we won't do extra operation, so directly pass to mini-rdr and quit */
9064 {
9066 }
9067
9069 RenameFcb = Stack->Parameters.SetFile.FileObject->FsContext;
9070 /* First, validate the received file object */
9073 {
9074 DPRINT1("Not the same device: %p:%p (%wZ) - %p:%p (%wZ)\n", Fcb, Fcb->pNetRoot, Fcb->pNetRoot->pNetRootName, RenameFcb, RenameFcb->pNetRoot, RenameFcb->pNetRoot->pNetRootName);
9076 }
9077
9078 /* We'll reallocate a safe buffer */
9079 Length = Fcb->pNetRoot->DiskParameters.RenameInfoOverallocationSize + RenameFcb->FcbTableEntry.Path.Length + FIELD_OFFSET(FILE_RENAME_INFORMATION, FileName);
9082 {
9084 }
9085
9086 _SEH2_TRY
9087 {
9088 /* Copy the data */
9093 RtlMoveMemory(&RenameInfo->FileName[0], RenameFcb->FcbTableEntry.Path.Buffer, RenameFcb->FcbTableEntry.Path.Length);
9094
9095 /* Set them in the RX_CONTEXT */
9097 RxContext->Info.Buffer = RenameInfo;
9099
9100 /* And call the mini-rdr */
9102 }
9103 _SEH2_FINALLY
9104 {
9105 /* Free */
9106 RxFreePoolWithTag(RenameInfo, '??xR');
9107 }
9108 _SEH2_END;
9109
9110 /* Done! */
9112}
Definition: winternl.h:654
Referenced by RxCommonSetInformation().
◆ RxSetSimpleInfo()
| NTSTATUS RxSetSimpleInfo | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 9136 of file rdbss.c.
Referenced by RxCommonSetInformation().
◆ RxSetupNetFileObject()
| VOID RxSetupNetFileObject | ( | PRX_CONTEXT | RxContext | ) |
Definition at line 9147 of file rdbss.c.
9149{
9151 PFOBX Fobx;
9154
9155 PAGED_CODE();
9156
9157 /* Assert FOBX is FOBX or NULL */
9160
9164 /* If it's temporary mark FO as such */
9167 {
9169 {
9170 return;
9171 }
9172
9174 }
9175
9176 /* No FO, nothing to setup */
9178 {
9179 return;
9180 }
9181
9182 /* Assign FCB & CCB (FOBX) to FO */
9184 FileObject->FsContext2 = Fobx;
9186 {
9187 ULONG_PTR StackTop, StackBottom;
9188
9189 /* If FO is allocated on pool, keep track of it */
9190 IoGetStackLimits(&StackTop, &StackBottom);
9192 {
9193 Fobx->AssociatedFileObject = FileObject;
9194 }
9195 else
9196 {
9197 Fobx->AssociatedFileObject = NULL;
9198 }
9199
9200 /* Make sure to mark FOBX if it's a DFS open */
9202 {
9204 }
9205 else
9206 {
9208 }
9209 }
9210
9211 /* Set Cc pointers */
9213
9214 /* Update access state */
9216 {
9218
9221 AccessState->RemainingDesiredAccess = 0;
9222 }
9223}
Definition: setypes.h:224
_In_opt_ PVOID _In_opt_ PUNICODE_STRING _In_ PSECURITY_DESCRIPTOR _In_ PACCESS_STATE AccessState
Definition: sefuncs.h:417
Referenced by RxCreateFromNetRoot().
◆ RxStartMinirdr()
Definition at line 9230 of file rdbss.c.
9233{
9237
9238 /* If we've not been post, then, do it */
9240 {
9242
9246
9247 *PostToFsp = TRUE;
9249 }
9250
9251 /* Acquire all the required locks */
9254 {
9255 *PostToFsp = TRUE;
9257 }
9258
9260 {
9262 *PostToFsp = TRUE;
9264 }
9265
9266 AlreadyStarted = FALSE;
9267 DeviceObject = RxContext->RxDeviceObject;
9268 _SEH2_TRY
9269 {
9270 /* MUP handle set, means already registered */
9272 {
9273 AlreadyStarted = TRUE;
9275 _SEH2_LEAVE;
9276 }
9277
9278 /* If we're asked to register to MUP, then do it */
9281 {
9283 &DeviceObject->DeviceName,
9284 DeviceObject->RegisterMailSlotProvider);
9285 }
9287 {
9289 _SEH2_LEAVE;
9290 }
9291
9292 /* Register as file system */
9295
9296 /* Inform mini-rdr it has to start */
9299 {
9300 ++DeviceObject->StartStopContext.Version;
9303
9305 }
9306 }
9307 _SEH2_FINALLY
9308 {
9310 {
9311 if (!AlreadyStarted)
9312 {
9314 }
9315 }
9316
9317 RxReleasePrefixTableLock(RxContext->RxDeviceObject->pRxNetNameTable);
9319 }
9320 _SEH2_END;
9321
9323}
_Inout_ PLIST_ENTRY _In_ PVOID _In_ PSTRING _In_ BOOLEAN _In_ BOOLEAN _In_ ULONG _In_ PFLT_CALLBACK_DATA _In_opt_ PCHECK_FOR_TRAVERSE_ACCESS _In_opt_ PSECURITY_SUBJECT_CONTEXT SubjectContext
Definition: fltkernel.h:2246
VOID NTAPI IoRegisterFileSystem(IN PDEVICE_OBJECT DeviceObject)
Definition: volume.c:987
VOID RxUnstart(PRX_CONTEXT Context, PRDBSS_DEVICE_OBJECT DeviceObject)
Definition: rdbss.c:9460
NTSTATUS RxInitializeMRxDispatcher(_Inout_ PRDBSS_DEVICE_OBJECT pMRxDeviceObject)
Definition: setypes.h:217
VOID NTAPI SeReleaseSubjectContext(_In_ PSECURITY_SUBJECT_CONTEXT SubjectContext)
Releases both the primary and client tokens of a security subject context.
Definition: subject.c:171
VOID NTAPI SeCaptureSubjectContext(_Out_ PSECURITY_SUBJECT_CONTEXT SubjectContext)
Captures the security subject context of the calling thread and calling process.
Definition: subject.c:85
NTSTATUS NTAPI FsRtlRegisterUncProvider(OUT PHANDLE Handle, IN PCUNICODE_STRING RedirectorDeviceName, IN BOOLEAN MailslotsSupported)
Definition: unc.c:280
◆ RxStopMinirdr()
◆ RxSystemControl()
| NTSTATUS RxSystemControl | ( | IN PRDBSS_DEVICE_OBJECT | RxDeviceObject, |
| IN PIRP | Irp | ||
| ) |
Definition at line 9336 of file rdbss.c.
Referenced by RxFsdDispatch().
◆ RxTryToBecomeTheTopLevelIrp()
| BOOLEAN RxTryToBecomeTheTopLevelIrp | ( | IN OUT PRX_TOPLEVELIRP_CONTEXT | TopLevelContext, |
| IN PIRP | Irp, | ||
| IN PRDBSS_DEVICE_OBJECT | RxDeviceObject, | ||
| IN BOOLEAN | ForceTopLevel | ||
| ) |
Definition at line 9348 of file rdbss.c.
9354{
9356
9357 PAGED_CODE();
9358
9359 /* If not top level, and not have to be, quit */
9361 {
9363 }
9364
9365 /* If not TLC provider, allocate one */
9367 {
9368 TopLevelContext = RxAllocatePoolWithTag(NonPagedPool, sizeof(RX_TOPLEVELIRP_CONTEXT), RX_TLC_POOLTAG);
9370 {
9372 }
9373
9374 FromPool = TRUE;
9375 }
9376
9377 /* Init it */
9379
9381 if (FromPool)
9382 {
9384 }
9385
9386 /* Make it top level IRP */
9389}
VOID __RxInitializeTopLevelIrpContext(IN OUT PRX_TOPLEVELIRP_CONTEXT TopLevelContext, IN PIRP Irp, IN PRDBSS_DEVICE_OBJECT RxDeviceObject, IN ULONG Flags)
Definition: rdbss.c:674
Referenced by RxFsdCommonDispatch(), and RxFspDispatch().
◆ RxUninitializeCacheMap()
| VOID RxUninitializeCacheMap | ( | PRX_CONTEXT | RxContext, |
| PFILE_OBJECT | FileObject, | ||
| PLARGE_INTEGER | TruncateSize | ||
| ) |
Definition at line 9414 of file rdbss.c.
9418{
9421 CACHE_UNINITIALIZE_EVENT UninitEvent;
9422
9423 PAGED_CODE();
9424
9428
9431
9432 /* Always release the FCB before waiting for the uninit event */
9434
9436
9437 /* Re-acquire it afterwards */
9440}
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
BOOLEAN NTAPI CcUninitializeCacheMap(IN PFILE_OBJECT FileObject, IN OPTIONAL PLARGE_INTEGER TruncateSize, IN OPTIONAL PCACHE_UNINITIALIZE_EVENT UninitializeEvent)
Definition: fssup.c:286
Definition: cctypes.h:45
Referenced by RxCommonCleanup().
◆ RxUnload()
| VOID NTAPI RxUnload | ( | IN PDRIVER_OBJECT | DriverObject | ) |
◆ RxUnlockOperation()
◆ RxUnstart()
| VOID RxUnstart | ( | PRX_CONTEXT | Context, |
| PRDBSS_DEVICE_OBJECT | DeviceObject | ||
| ) |
Definition at line 9460 of file rdbss.c.
Referenced by RxStartMinirdr().
◆ RxUnwindTopLevelIrp()
| VOID RxUnwindTopLevelIrp | ( | IN OUT PRX_TOPLEVELIRP_CONTEXT | TopLevelContext | ) |
Definition at line 9471 of file rdbss.c.
9473{
9475
9476 /* No TLC provided? Ask the system for ours! */
9478 {
9481 {
9482 return;
9483 }
9484
9485 /* In that case, just assert it's really ours */
9488 }
9489
9492 /* Restore the previous top level IRP */
9493 IoSetTopLevelIrp(TopLevelContext->Previous);
9494 /* If TLC was allocated from pool, remove it from list and release it */
9496 {
9497 RxRemoveFromTopLevelIrpAllocatedContextsList(TopLevelContext);
9498 RxFreePoolWithTag(TopLevelContext, RX_TLC_POOLTAG);
9499 }
9500}
VOID RxRemoveFromTopLevelIrpAllocatedContextsList(PRX_TOPLEVELIRP_CONTEXT TopLevelContext)
Definition: rdbss.c:8562
Referenced by RxFsdCommonDispatch(), and RxFspDispatch().
◆ RxUpdateShareAccessPerSrvOpens()
Definition at line 9506 of file rdbss.c.
9508{
9512 BOOLEAN DeleteAccess;
9513
9514 PAGED_CODE();
9515
9516 /* If already updated, no need to continue */
9518 {
9519 return;
9520 }
9521
9522 /* Check if any access wanted */
9523 DesiredAccess = SrvOpen->DesiredAccess;
9527
9528 /* In that case, update it */
9530 {
9531 BOOLEAN SharedRead;
9532 BOOLEAN SharedWrite;
9533 BOOLEAN SharedDelete;
9536
9538 DesiredShareAccess = SrvOpen->ShareAccess;
9539
9543
9544 ShareAccess->OpenCount++;
9545
9548 ShareAccess->Deleters += DeleteAccess;
9549 ShareAccess->SharedRead += SharedRead;
9550 ShareAccess->SharedWrite += SharedWrite;
9551 ShareAccess->SharedDelete += SharedDelete;
9552 }
9553
9555}
Referenced by RxCreateFromNetRoot().
◆ RxXXXControlFileCallthru()
| NTSTATUS RxXXXControlFileCallthru | ( | PRX_CONTEXT | Context | ) |
Definition at line 9561 of file rdbss.c.
9563{
9565
9566 PAGED_CODE();
9567
9569
9570 /* No dispatch table? Nothing to dispatch */
9572 {
9575 }
9576
9577 /* Init the lowio context */
9580 {
9582 }
9583
9584 /* Check whether we're consistent: a length means a buffer */
9585 if ((Context->LowIoContext.ParamsFor.FsCtl.InputBufferLength > 0 && Context->LowIoContext.ParamsFor.FsCtl.pInputBuffer == NULL) ||
9586 (Context->LowIoContext.ParamsFor.FsCtl.OutputBufferLength > 0 && Context->LowIoContext.ParamsFor.FsCtl.pOutputBuffer == NULL))
9587 {
9589 }
9590
9591 /* Forward the call to the mini-rdr */
9595 {
9597 }
9598
9599 DPRINT("RxXXXControlFileCallthru: %x, %ld\n", Context->CurrentIrp->IoStatus.Status, Context->CurrentIrp->IoStatus.Information);
9601}
NTSTATUS NTAPI RxLowIoPopulateFsctlInfo(_In_ PRX_CONTEXT RxContext)
Referenced by RxCommonDevFCBIoCtl().
Variable Documentation
◆ DisableByteRangeLockingOnReadOnlyFiles
Definition at line 532 of file rdbss.c.
Referenced by RxReadRegistryParameters(), and RxSearchForCollapsibleOpen().
◆ DisableFlushOnCleanup
Definition at line 533 of file rdbss.c.
Referenced by RxCommonCleanup(), and RxReadRegistryParameters().
◆ ReadAheadGranularity
| ULONG ReadAheadGranularity = 1 << PAGE_SHIFT |
Definition at line 534 of file rdbss.c.
Referenced by RxCreateNetRoot(), and RxReadRegistryParameters().
◆ Rx8QMdot3QM
| WCHAR Rx8QMdot3QM[] = L">>>>>>>>.>>>*" |
Definition at line 531 of file rdbss.c.
Referenced by RxQueryDirectory().
◆ RxActiveContexts
| LIST_ENTRY RxActiveContexts |
Definition at line 535 of file rdbss.c.
Referenced by RxCancelNotifyChangeDirectoryRequestsForFobx(), RxCancelNotifyChangeDirectoryRequestsForVNetRoot(), RxCancelRoutine(), RxCreateRxContext(), and RxDriverEntry().
◆ RxContextLookasideList
| NPAGED_LOOKASIDE_LIST RxContextLookasideList |
Definition at line 536 of file rdbss.c.
Referenced by RxCreateRxContext(), RxDereferenceAndDeleteRxContext_Real(), and RxDriverEntry().
◆ RxData
| RDBSS_DATA RxData |
Definition at line 537 of file rdbss.c.
Referenced by RxCommonRead(), RxCommonWrite(), RxDriverEntry(), RxGetRDBSSProcess(), RxInitializeDispatchVectors(), RxInitializeRegistrationStructures(), RxRegisterMinirdr(), and RxStartMinirdr().
◆ RxDeviceFCB
| FCB RxDeviceFCB |
Definition at line 538 of file rdbss.c.
Referenced by RxCommonCreate(), RxCreateTreeConnect(), RxDriverEntry(), RxFsdCommonDispatch(), and RxInitializeDispatchVectors().
◆ RxDeviceFCBVector
| RX_FSD_DISPATCH_VECTOR RxDeviceFCBVector[IRP_MJ_MAXIMUM_FUNCTION+1] |
Definition at line 540 of file rdbss.c.
Referenced by RxFsdCommonDispatch(), and RxInitializeDispatchVectors().
◆ RxExports
| RDBSS_EXPORTS RxExports |
Definition at line 571 of file rdbss.c.
Referenced by RxDriverEntry(), and RxRegisterMinirdr().
◆ RxFastIoDispatch
| FAST_IO_DISPATCH RxFastIoDispatch |
Definition at line 572 of file rdbss.c.
Referenced by RxInitializeDispatchVectors().
◆ RxFileSystemDeviceObject
| PRDBSS_DEVICE_OBJECT RxFileSystemDeviceObject |
Definition at line 573 of file rdbss.c.
Referenced by RxAddToWorkque(), RxCancelOperationInOverflowQueue(), RxCancelRoutine(), RxCompleteSrvOpenKeyAssociation(), RxCreateSrvCallCallBack(), RxDriverEntry(), RxFsdDispatch(), RxFspDispatch(), RxGetStringRegistryParameter(), RxInitializeDispatcher(), RxMarkFobxOnCleanup(), RxpDispatchChangeBufferingStateRequests(), RxpMarkInstanceForScavengedFinalization(), RxRegisterMinirdr(), and RxScavengerTimerRoutine().
◆ RxForceQFIPassThrough
Definition at line 613 of file rdbss.c.
Referenced by RxQueryStandardInfo().
◆ RxFsdDispatchVector
| RX_FSD_DISPATCH_VECTOR RxFsdDispatchVector[IRP_MJ_MAXIMUM_FUNCTION+1] |
Definition at line 574 of file rdbss.c.
Referenced by RxFsdDispatch(), and RxInitializeDispatchVectors().
◆ RxFsdEntryCount
| ULONG RxFsdEntryCount |
Definition at line 605 of file rdbss.c.
Referenced by RxCreateRxContext().
◆ RxIrpsList
| LIST_ENTRY RxIrpsList |
Definition at line 606 of file rdbss.c.
Referenced by RxDriverEntry().
◆ RxIrpsListSpinLock
| KSPIN_LOCK RxIrpsListSpinLock |
Definition at line 607 of file rdbss.c.
Referenced by RxDriverEntry().
◆ RxLoudLowIoOpsEnabled
Definition at line 539 of file rdbss.c.
Referenced by CheckForLoudOperations().
◆ RxNoAsync
Definition at line 614 of file rdbss.c.
Referenced by RxCommonWrite().
◆ RxScavengerMutex
| KMUTEX RxScavengerMutex |
Definition at line 608 of file rdbss.c.
Referenced by RxDriverEntry().
◆ RxSerializationMutex
| KMUTEX RxSerializationMutex |
Definition at line 609 of file rdbss.c.
Referenced by RxDriverEntry().
◆ RxSpaceForTheWrappersDeviceObject
| UCHAR RxSpaceForTheWrappersDeviceObject[sizeof(*RxFileSystemDeviceObject)] |
Definition at line 610 of file rdbss.c.
Referenced by RxDriverEntry().
◆ RxStarForTemplate
| WCHAR RxStarForTemplate = '*' |
Definition at line 530 of file rdbss.c.
Referenced by RxQueryDirectory().
◆ TopLevelIrpAllocatedContextsList
| LIST_ENTRY TopLevelIrpAllocatedContextsList |
Definition at line 612 of file rdbss.c.
Referenced by RxAddToTopLevelIrpAllocatedContextsList(), RxInitializeTopLevelIrpPackage(), and RxIsMemberOfTopLevelIrpAllocatedContextsList().
◆ TopLevelIrpSpinLock
| KSPIN_LOCK TopLevelIrpSpinLock |
Definition at line 611 of file rdbss.c.
Referenced by RxAddToTopLevelIrpAllocatedContextsList(), RxInitializeTopLevelIrpPackage(), RxIsMemberOfTopLevelIrpAllocatedContextsList(), and RxRemoveFromTopLevelIrpAllocatedContextsList().
