Ros-diffs May 2018

ros-diffs@reactos.org

23 participants
218 discussions

04/04: [LDR] Initial verifier implementation

by Mark Jansen

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=60a1006d0f8a0bb658c78… commit 60a1006d0f8a0bb658c7881e48fc5ee8165a2c0c Author: Mark Jansen <mark.jansen(a)reactos.org> AuthorDate: Fri Apr 27 22:43:45 2018 +0200 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat May 12 13:35:10 2018 +0200 [LDR] Initial verifier implementation --- dll/ntdll/CMakeLists.txt | 1 + dll/ntdll/include/ntdllp.h | 21 ++ dll/ntdll/ldr/ldrapi.c | 2 +- dll/ntdll/ldr/ldrinit.c | 34 +-- dll/ntdll/ldr/ldrpe.c | 16 +- dll/ntdll/ldr/verifier.c | 685 +++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 719 insertions(+), 40 deletions(-) diff --git a/dll/ntdll/CMakeLists.txt b/dll/ntdll/CMakeLists.txt index aefdaf5c40..e94db5c77a 100644 --- a/dll/ntdll/CMakeLists.txt +++ b/dll/ntdll/CMakeLists.txt @@ -19,6 +19,7 @@ list(APPEND SOURCE ldr/ldrinit.c ldr/ldrpe.c ldr/ldrutils.c + ldr/verifier.c rtl/libsupp.c rtl/uilist.c rtl/version.c diff --git a/dll/ntdll/include/ntdllp.h b/dll/ntdll/include/ntdllp.h index 4d6086730e..29ade67b45 100644 --- a/dll/ntdll/include/ntdllp.h +++ b/dll/ntdll/include/ntdllp.h @@ -46,6 +46,7 @@ extern ULONG LdrpActiveUnloadCount; extern BOOLEAN LdrpShutdownInProgress; extern UNICODE_STRING LdrpKnownDllPath; extern PLDR_DATA_TABLE_ENTRY LdrpGetModuleHandleCache, LdrpLoadedDllHandleCache; +extern BOOLEAN RtlpPageHeapEnabled; extern ULONG RtlpDphGlobalFlags; extern BOOLEAN g_ShimsEnabled; extern PVOID g_pShimEngineModule; @@ -158,6 +159,26 @@ LdrpLoadShimEngine(IN PWSTR ImageName, VOID NTAPI LdrpUnloadShimEngine(VOID); +/* verifier.c */ + +NTSTATUS NTAPI +LdrpInitializeApplicationVerifierPackage(IN HANDLE KeyHandle, + IN PPEB Peb, + IN BOOLEAN SystemWide, + IN BOOLEAN ReadAdvancedOptions); + +NTSTATUS NTAPI +AVrfInitializeVerifier(VOID); + +VOID NTAPI +AVrfDllLoadNotification(IN PLDR_DATA_TABLE_ENTRY LdrEntry); + +VOID NTAPI +AVrfDllUnloadNotification(IN PLDR_DATA_TABLE_ENTRY LdrEntry); + +VOID NTAPI +AVrfPageHeapDllNotification(IN PLDR_DATA_TABLE_ENTRY LdrEntry); + /* FIXME: Cleanup this mess */ typedef NTSTATUS (NTAPI *PEPFUNC)(PPEB); diff --git a/dll/ntdll/ldr/ldrapi.c b/dll/ntdll/ldr/ldrapi.c index c33b21eff1..2f8cc68340 100644 --- a/dll/ntdll/ldr/ldrapi.c +++ b/dll/ntdll/ldr/ldrapi.c @@ -1503,7 +1503,7 @@ LdrUnloadDll(IN PVOID BaseAddress) /* Notify Application Verifier */ if (Peb->NtGlobalFlag & FLG_HEAP_ENABLE_TAIL_CHECK) { - DPRINT1("We don't support Application Verifier yet\n"); + AVrfDllUnloadNotification(LdrEntry); } /* Show message */ diff --git a/dll/ntdll/ldr/ldrinit.c b/dll/ntdll/ldr/ldrinit.c index a5655eca41..902a797d15 100644 --- a/dll/ntdll/ldr/ldrinit.c +++ b/dll/ntdll/ldr/ldrinit.c @@ -82,7 +82,6 @@ ULONG LdrpActiveUnloadCount; VOID NTAPI RtlpInitializeVectoredExceptionHandling(VOID); VOID NTAPI RtlpInitDeferedCriticalSection(VOID); VOID NTAPI RtlInitializeHeapManager(VOID); -extern BOOLEAN RtlpPageHeapEnabled; ULONG RtlpDisableHeapLookaside; // TODO: Move to heap.c ULONG RtlpShutdownProcessFlags; // TODO: Use it @@ -1311,26 +1310,6 @@ LdrpFreeTls(VOID) TlsVector); } -NTSTATUS -NTAPI -LdrpInitializeApplicationVerifierPackage(PUNICODE_STRING ImagePathName, PPEB Peb, BOOLEAN SystemWide, BOOLEAN ReadAdvancedOptions) -{ - /* If global flags request DPH, perform some additional actions */ - if (Peb->NtGlobalFlag & FLG_HEAP_PAGE_ALLOCS) - { - // TODO: Read advanced DPH flags from the registry if requested - if (ReadAdvancedOptions) - { - UNIMPLEMENTED; - } - - /* Enable page heap */ - RtlpPageHeapEnabled = TRUE; - } - - return STATUS_SUCCESS; -} - NTSTATUS NTAPI LdrpInitializeExecutionOptions(PUNICODE_STRING ImagePathName, PPEB Peb, PHANDLE OptionsKey) @@ -1426,7 +1405,7 @@ LdrpInitializeExecutionOptions(PUNICODE_STRING ImagePathName, PPEB Peb, PHANDLE /* Call AVRF if necessary */ if (Peb->NtGlobalFlag & (FLG_APPLICATION_VERIFIER | FLG_HEAP_PAGE_ALLOCS)) { - Status = LdrpInitializeApplicationVerifierPackage(ImagePathName, Peb, TRUE, FALSE); + Status = LdrpInitializeApplicationVerifierPackage(KeyHandle, Peb, TRUE, FALSE); if (!NT_SUCCESS(Status)) { DPRINT1("AVRF: LdrpInitializeApplicationVerifierPackage failed with %08X\n", Status); @@ -1439,7 +1418,7 @@ LdrpInitializeExecutionOptions(PUNICODE_STRING ImagePathName, PPEB Peb, PHANDLE if (Peb->NtGlobalFlag & (FLG_APPLICATION_VERIFIER | FLG_HEAP_PAGE_ALLOCS)) { /* Initialize app verifier package */ - Status = LdrpInitializeApplicationVerifierPackage(ImagePathName, Peb, TRUE, FALSE); + Status = LdrpInitializeApplicationVerifierPackage(KeyHandle, Peb, TRUE, FALSE); if (!NT_SUCCESS(Status)) { DPRINT1("AVRF: LdrpInitializeApplicationVerifierPackage failed with %08X\n", Status); @@ -2057,8 +2036,13 @@ LdrpInitializeProcess(IN PCONTEXT Context, /* Check if the Application Verifier was enabled */ if (Peb->NtGlobalFlag & FLG_APPLICATION_VERIFIER) { - /* FIXME */ - DPRINT1("We don't support Application Verifier yet\n"); + Status = AVrfInitializeVerifier(); + if (!NT_SUCCESS(Status)) + { + DPRINT1("LDR: AVrfInitializeVerifier failed (ntstatus 0x%x)\n", Status); + return Status; + } + } if (IsDotNetImage) diff --git a/dll/ntdll/ldr/ldrpe.c b/dll/ntdll/ldr/ldrpe.c index fb217ed686..598e3e5477 100644 --- a/dll/ntdll/ldr/ldrpe.c +++ b/dll/ntdll/ldr/ldrpe.c @@ -20,17 +20,6 @@ ULONG LdrpNormalSnap; /* FUNCTIONS *****************************************************************/ -VOID -NTAPI -AVrfPageHeapDllNotification(IN PLDR_DATA_TABLE_ENTRY LdrEntry) -{ - /* Check if page heap dll notification is turned on */ - if (!(RtlpDphGlobalFlags & DPH_FLAG_DLL_NOTIFY)) - return; - - /* We don't support this flag currently */ - UNIMPLEMENTED; -} NTSTATUS NTAPI @@ -795,10 +784,9 @@ LdrpWalkImportDescriptor(IN LPWSTR DllPath OPTIONAL, } /* Check if Application Verifier was enabled */ - if (Peb->NtGlobalFlag & FLG_HEAP_ENABLE_TAIL_CHECK) + if (Peb->NtGlobalFlag & FLG_APPLICATION_VERIFIER) { - /* FIXME */ - DPRINT1("We don't support Application Verifier yet!\n"); + AVrfDllLoadNotification(LdrEntry); } /* Just to be safe */ diff --git a/dll/ntdll/ldr/verifier.c b/dll/ntdll/ldr/verifier.c new file mode 100644 index 0000000000..6a44572a19 --- /dev/null +++ b/dll/ntdll/ldr/verifier.c @@ -0,0 +1,685 @@ +/* + * PROJECT: ReactOS NT User Mode Library + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: Verifier support routines + * COPYRIGHT: Copyright 2011 Aleksey Bragin (aleksey(a)reactos.org) + * Copyright 2018 Mark Jansen (mark.jansen(a)reactos.org) + */ + + +#include <ntdll.h> +#include <reactos/verifier.h> + +#define NDEBUG +#include <debug.h> + +extern PLDR_DATA_TABLE_ENTRY LdrpImageEntry; +ULONG AVrfpVerifierFlags = 0; +WCHAR AVrfpVerifierDllsString[256] = { 0 }; +ULONG AVrfpDebug = 0; +BOOL AVrfpInitialized = FALSE; +RTL_CRITICAL_SECTION AVrfpVerifierLock; +LIST_ENTRY AVrfpVerifierProvidersList; + +#define VERIFIER_DLL_FLAGS_RESOLVED 1 + + +typedef struct _VERIFIER_PROVIDER +{ + LIST_ENTRY ListEntry; + UNICODE_STRING DllName; + PVOID BaseAddress; + PVOID EntryPoint; + + // Provider data + PRTL_VERIFIER_DLL_DESCRIPTOR ProviderDlls; + RTL_VERIFIER_DLL_LOAD_CALLBACK ProviderDllLoadCallback; + RTL_VERIFIER_DLL_UNLOAD_CALLBACK ProviderDllUnloadCallback; + RTL_VERIFIER_NTDLLHEAPFREE_CALLBACK ProviderNtdllHeapFreeCallback; +} VERIFIER_PROVIDER, *PVERIFIER_PROVIDER; + + + + +VOID +NTAPI +AVrfReadIFEO(HANDLE KeyHandle) +{ + NTSTATUS Status; + + Status = LdrQueryImageFileKeyOption(KeyHandle, + L"VerifierDlls", + REG_SZ, + AVrfpVerifierDllsString, + sizeof(AVrfpVerifierDllsString) - sizeof(WCHAR), + NULL); + + if (!NT_SUCCESS(Status)) + AVrfpVerifierDllsString[0] = UNICODE_NULL; + + Status = LdrQueryImageFileKeyOption(KeyHandle, + L"VerifierFlags", + REG_DWORD, + &AVrfpVerifierFlags, + sizeof(AVrfpVerifierFlags), + NULL); + if (!NT_SUCCESS(Status)) + AVrfpVerifierFlags = RTL_VRF_FLG_HANDLE_CHECKS | RTL_VRF_FLG_FAST_FILL_HEAP | RTL_VRF_FLG_LOCK_CHECKS; + + Status = LdrQueryImageFileKeyOption(KeyHandle, + L"VerifierDebug", + REG_DWORD, + &AVrfpDebug, + sizeof(AVrfpDebug), + NULL); + if (!NT_SUCCESS(Status)) + AVrfpDebug = 0; +} + + +NTSTATUS +NTAPI +LdrpInitializeApplicationVerifierPackage(HANDLE KeyHandle, PPEB Peb, BOOLEAN SystemWide, BOOLEAN ReadAdvancedOptions) +{ + /* If global flags request DPH, perform some additional actions */ + if (Peb->NtGlobalFlag & FLG_HEAP_PAGE_ALLOCS) + { + // TODO: Read advanced DPH flags from the registry if requested + if (ReadAdvancedOptions) + { + UNIMPLEMENTED; + } + + /* Enable page heap */ + RtlpPageHeapEnabled = TRUE; + } + + AVrfReadIFEO(KeyHandle); + + return STATUS_SUCCESS; +} + +BOOLEAN +AVrfpIsVerifierProviderDll(PVOID BaseAddress) +{ + PLIST_ENTRY Entry; + PVERIFIER_PROVIDER Provider; + + for (Entry = AVrfpVerifierProvidersList.Flink; Entry != &AVrfpVerifierProvidersList; Entry = Entry->Flink) + { + Provider = CONTAINING_RECORD(Entry, VERIFIER_PROVIDER, ListEntry); + + if (BaseAddress == Provider->BaseAddress) + return TRUE; + } + + return FALSE; +} + +SIZE_T +AVrfpCountThunks(PIMAGE_THUNK_DATA Thunk) +{ + SIZE_T Count = 0; + while (Thunk[Count].u1.Function) + Count++; + return Count; +} + +VOID +AVrfpSnapDllImports(IN PLDR_DATA_TABLE_ENTRY LdrEntry) +{ + ULONG Size; + PIMAGE_IMPORT_DESCRIPTOR ImportDescriptor; + PBYTE DllBase = LdrEntry->DllBase; + + ImportDescriptor = RtlImageDirectoryEntryToData(DllBase, TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &Size); + if (!ImportDescriptor) + { + //SHIMENG_INFO("Skipping module 0x%p \"%wZ\" due to no iat found\n", LdrEntry->DllBase, &LdrEntry->BaseDllName); + return; + } + + for (; ImportDescriptor->Name && ImportDescriptor->OriginalFirstThunk; ImportDescriptor++) + { + PIMAGE_THUNK_DATA FirstThunk; + PVOID UnprotectedPtr = NULL; + SIZE_T UnprotectedSize = 0; + ULONG OldProtection = 0; + FirstThunk = (PIMAGE_THUNK_DATA)(DllBase + ImportDescriptor->FirstThunk); + + /* Walk all imports */ + for (;FirstThunk->u1.Function; FirstThunk++) + { + PLIST_ENTRY Entry; + PVERIFIER_PROVIDER Provider; + + for (Entry = AVrfpVerifierProvidersList.Flink; Entry != &AVrfpVerifierProvidersList; Entry = Entry->Flink) + { + PRTL_VERIFIER_DLL_DESCRIPTOR DllDescriptor; + + Provider = CONTAINING_RECORD(Entry, VERIFIER_PROVIDER, ListEntry); + for (DllDescriptor = Provider->ProviderDlls; DllDescriptor && DllDescriptor->DllName; ++DllDescriptor) + { + PRTL_VERIFIER_THUNK_DESCRIPTOR ThunkDescriptor; + + for (ThunkDescriptor = DllDescriptor->DllThunks; ThunkDescriptor && ThunkDescriptor->ThunkName; ++ThunkDescriptor) + { + /* Just compare function addresses, the loader will have handled forwarders and ordinals for us */ + if ((PVOID)FirstThunk->u1.Function != ThunkDescriptor->ThunkOldAddress) + continue; + + if (!UnprotectedPtr) + { + PVOID Ptr = &FirstThunk->u1.Function; + SIZE_T Size = sizeof(FirstThunk->u1.Function) * AVrfpCountThunks(FirstThunk); + NTSTATUS Status; + + UnprotectedPtr = Ptr; + UnprotectedSize = Size; + + Status = NtProtectVirtualMemory(NtCurrentProcess(), + &Ptr, + &Size, + PAGE_EXECUTE_READWRITE, + &OldProtection); + + if (!NT_SUCCESS(Status)) + { + DbgPrint("AVRF: Unable to unprotect IAT to modify thunks (status %08X).\n", Status); + UnprotectedPtr = NULL; + continue; + } + } + + if (ThunkDescriptor->ThunkNewAddress == NULL) + { + DbgPrint("AVRF: internal error: New thunk for %s is null.\n", ThunkDescriptor->ThunkName); + continue; + } + FirstThunk->u1.Function = (SIZE_T)ThunkDescriptor->ThunkNewAddress; + if (AVrfpDebug & RTL_VRF_DBG_SHOWSNAPS) + DbgPrint("AVRF: Snapped (%wZ: %s) with (%wZ: %p).\n", + &LdrEntry->BaseDllName, + ThunkDescriptor->ThunkName, + &Provider->DllName, + ThunkDescriptor->ThunkNewAddress); + } + } + } + } + + if (UnprotectedPtr) + { + PVOID Ptr = UnprotectedPtr; + SIZE_T Size = UnprotectedSize; + NTSTATUS Status; + + UnprotectedPtr = Ptr; + UnprotectedSize = Size; + + Status = NtProtectVirtualMemory(NtCurrentProcess(), + &Ptr, + &Size, + OldProtection, + &OldProtection); + if (!NT_SUCCESS(Status)) + { + DbgPrint("AVRF: Unable to reprotect IAT to modify thunks (status %08X).\n", Status); + } + } + } +} + + +VOID +AvrfpResolveThunks(IN PLDR_DATA_TABLE_ENTRY LdrEntry) +{ + PLIST_ENTRY Entry; + PVERIFIER_PROVIDER Provider; + + if (!AVrfpInitialized) + return; + + for (Entry = AVrfpVerifierProvidersList.Flink; Entry != &AVrfpVerifierProvidersList; Entry = Entry->Flink) + { + PRTL_VERIFIER_DLL_DESCRIPTOR DllDescriptor; + + Provider = CONTAINING_RECORD(Entry, VERIFIER_PROVIDER, ListEntry); + + for (DllDescriptor = Provider->ProviderDlls; DllDescriptor && DllDescriptor->DllName; ++DllDescriptor) + { + PRTL_VERIFIER_THUNK_DESCRIPTOR ThunkDescriptor; + + if ((DllDescriptor->DllFlags & VERIFIER_DLL_FLAGS_RESOLVED) || + _wcsicmp(DllDescriptor->DllName, LdrEntry->BaseDllName.Buffer)) + continue; + + if (AVrfpDebug & RTL_VRF_DBG_SHOWVERIFIEDEXPORTS) + DbgPrint("AVRF: pid 0x%X: found dll descriptor for `%wZ' with verified exports\n", + NtCurrentTeb()->ClientId.UniqueProcess, + &LdrEntry->BaseDllName); + + for (ThunkDescriptor = DllDescriptor->DllThunks; ThunkDescriptor && ThunkDescriptor->ThunkName; ++ThunkDescriptor) + { + if (!ThunkDescriptor->ThunkOldAddress) + { + ANSI_STRING ThunkName; + + RtlInitAnsiString(&ThunkName, ThunkDescriptor->ThunkName); + /* We cannot call the public api, because that would run init routines! */ + if (NT_SUCCESS(LdrpGetProcedureAddress(LdrEntry->DllBase, &ThunkName, 0, &ThunkDescriptor->ThunkOldAddress, FALSE))) + { + if (AVrfpDebug & RTL_VRF_DBG_SHOWFOUNDEXPORTS) + DbgPrint("AVRF: (%wZ) %Z export found.\n", &LdrEntry->BaseDllName, &ThunkName); + } + else + { + if (AVrfpDebug & RTL_VRF_DBG_SHOWFOUNDEXPORTS) + DbgPrint("AVRF: warning: did not find `%Z' export in %wZ.\n", &ThunkName, &LdrEntry->BaseDllName); + } + } + } + + DllDescriptor->DllFlags |= VERIFIER_DLL_FLAGS_RESOLVED; + } + } + + AVrfpSnapDllImports(LdrEntry); +} + + + +VOID +NTAPI +AVrfDllLoadNotification(IN PLDR_DATA_TABLE_ENTRY LdrEntry) +{ + PLIST_ENTRY Entry; + + if (!(NtCurrentPeb()->NtGlobalFlag & FLG_APPLICATION_VERIFIER)) + return; + + RtlEnterCriticalSection(&AVrfpVerifierLock); + if (!AVrfpIsVerifierProviderDll(LdrEntry->DllBase)) + { + AvrfpResolveThunks(LdrEntry); + + for (Entry = AVrfpVerifierProvidersList.Flink; Entry != &AVrfpVerifierProvidersList; Entry = Entry->Flink) + { + PVERIFIER_PROVIDER Provider; + RTL_VERIFIER_DLL_LOAD_CALLBACK ProviderDllLoadCallback; + + Provider = CONTAINING_RECORD(Entry, VERIFIER_PROVIDER, ListEntry); + + ProviderDllLoadCallback = Provider->ProviderDllLoadCallback; + if (ProviderDllLoadCallback) + { + ProviderDllLoadCallback(LdrEntry->BaseDllName.Buffer, + LdrEntry->DllBase, + LdrEntry->SizeOfImage, + LdrEntry); + } + } + } + RtlLeaveCriticalSection(&AVrfpVerifierLock); +} + +VOID +NTAPI +AVrfDllUnloadNotification(IN PLDR_DATA_TABLE_ENTRY LdrEntry) +{ + PLIST_ENTRY Entry; + + if (!(NtCurrentPeb()->NtGlobalFlag & FLG_APPLICATION_VERIFIER)) + return; + + RtlEnterCriticalSection(&AVrfpVerifierLock); + if (!AVrfpIsVerifierProviderDll(LdrEntry->DllBase)) + { + for (Entry = AVrfpVerifierProvidersList.Flink; Entry != &AVrfpVerifierProvidersList; Entry = Entry->Flink) + { + PVERIFIER_PROVIDER Provider; + RTL_VERIFIER_DLL_UNLOAD_CALLBACK ProviderDllUnloadCallback; + + Provider = CONTAINING_RECORD(Entry, VERIFIER_PROVIDER, ListEntry); + + ProviderDllUnloadCallback = Provider->ProviderDllUnloadCallback; + if (ProviderDllUnloadCallback) + { + ProviderDllUnloadCallback(LdrEntry->BaseDllName.Buffer, + LdrEntry->DllBase, + LdrEntry->SizeOfImage, + LdrEntry); + } + } + } + RtlLeaveCriticalSection(&AVrfpVerifierLock); +} + + +VOID +NTAPI +AVrfPageHeapDllNotification(IN PLDR_DATA_TABLE_ENTRY LdrEntry) +{ + /* Check if page heap dll notification is turned on */ + if (!(RtlpDphGlobalFlags & DPH_FLAG_DLL_NOTIFY)) + return; + + /* We don't support this flag currently */ + UNIMPLEMENTED; +} + + +VOID +NTAPI +AVrfpResnapInitialModules(VOID) +{ + PLIST_ENTRY ListHead, ListEntry; + + ListHead = &NtCurrentPeb()->Ldr->InLoadOrderModuleList; + for (ListEntry = ListHead->Flink; ListHead != ListEntry; ListEntry = ListEntry->Flink) + { + PLDR_DATA_TABLE_ENTRY LdrEntry; + + LdrEntry = CONTAINING_RECORD(ListEntry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks); + + if (AVrfpIsVerifierProviderDll(LdrEntry->DllBase)) + { + if (AVrfpDebug & RTL_VRF_DBG_SHOWSNAPS) + DbgPrint("AVRF: skipped resnapping provider %wZ ...\n", &LdrEntry->BaseDllName); + } + else + { + if (AVrfpDebug & RTL_VRF_DBG_SHOWSNAPS) + DbgPrint("AVRF: resnapping %wZ ...\n", &LdrEntry->BaseDllName); + + AvrfpResolveThunks(LdrEntry); + } + } +} + +PVOID +NTAPI +AvrfpFindDuplicateThunk(PLIST_ENTRY EndEntry, PWCHAR DllName, PCHAR ThunkName) +{ + PLIST_ENTRY Entry; + + for (Entry = AVrfpVerifierProvidersList.Flink; Entry != EndEntry; Entry = Entry->Flink) + { + PVERIFIER_PROVIDER Provider; + PRTL_VERIFIER_DLL_DESCRIPTOR DllDescriptor; + + Provider = CONTAINING_RECORD(Entry, VERIFIER_PROVIDER, ListEntry); + + if (AVrfpDebug & RTL_VRF_DBG_SHOWCHAINING_DEBUG) + DbgPrint("AVRF: chain: searching in %wZ\n", &Provider->DllName); + + for (DllDescriptor = Provider->ProviderDlls; DllDescriptor && DllDescriptor->DllName; ++DllDescriptor) + { + PRTL_VERIFIER_THUNK_DESCRIPTOR ThunkDescriptor; + + if (AVrfpDebug & RTL_VRF_DBG_SHOWCHAINING_DEBUG) + DbgPrint("AVRF: chain: dll: %ws\n", DllDescriptor->DllName); + + if (_wcsicmp(DllDescriptor->DllName, DllName)) + continue; + + for (ThunkDescriptor = DllDescriptor->DllThunks; ThunkDescriptor && ThunkDescriptor->ThunkName; ++ThunkDescriptor) + { + if (AVrfpDebug & RTL_VRF_DBG_SHOWCHAINING_DEBUG) + DbgPrint("AVRF: chain: thunk: %s == %s ?\n", ThunkDescriptor->ThunkName, ThunkName); + + if (!_stricmp(ThunkDescriptor->ThunkName, ThunkName)) + { + if (AVrfpDebug & RTL_VRF_DBG_SHOWCHAINING_DEBUG) + DbgPrint("AVRF: Found duplicate for (%ws: %s) in %wZ\n", + DllDescriptor->DllName, ThunkDescriptor->ThunkName, &Provider->DllName); + + return ThunkDescriptor->ThunkNewAddress; + } + } + } + } + return NULL; +} + + +VOID +NTAPI +AVrfpChainDuplicateThunks(VOID) +{ + PLIST_ENTRY Entry; + PVERIFIER_PROVIDER Provider; + + for (Entry = AVrfpVerifierProvidersList.Flink; Entry != &AVrfpVerifierProvidersList; Entry = Entry->Flink) + { + PRTL_VERIFIER_DLL_DESCRIPTOR DllDescriptor; + PRTL_VERIFIER_THUNK_DESCRIPTOR ThunkDescriptor; + + Provider = CONTAINING_RECORD(Entry, VERIFIER_PROVIDER, ListEntry); + + for (DllDescriptor = Provider->ProviderDlls; DllDescriptor && DllDescriptor->DllName; ++DllDescriptor) + { + for (ThunkDescriptor = DllDescriptor->DllThunks; ThunkDescriptor && ThunkDescriptor->ThunkName; ++ThunkDescriptor) + { + PVOID Ptr; + + if (AVrfpDebug & RTL_VRF_DBG_SHOWCHAINING_DEBUG) + DbgPrint("AVRF: Checking %wZ for duplicate (%ws: %s)\n", + &Provider->DllName, DllDescriptor->DllName, ThunkDescriptor->ThunkName); + + Ptr = AvrfpFindDuplicateThunk(Entry, DllDescriptor->DllName, ThunkDescriptor->ThunkName); + if (Ptr) + { + if (AVrfpDebug & RTL_VRF_DBG_SHOWCHAINING) + DbgPrint("AVRF: Chaining (%ws: %s) to %wZ\n", DllDescriptor->DllName, ThunkDescriptor->ThunkName, &Provider->DllName); + + ThunkDescriptor->ThunkOldAddress = Ptr; + } + } + } + } +} + +NTSTATUS +NTAPI +AVrfpLoadAndInitializeProvider(PVERIFIER_PROVIDER Provider) +{ + WCHAR StringBuffer[MAX_PATH + 11]; + UNICODE_STRING DllPath; + PRTL_VERIFIER_PROVIDER_DESCRIPTOR Descriptor; + PIMAGE_NT_HEADERS ImageNtHeader; + NTSTATUS Status; + + RtlInitEmptyUnicodeString(&DllPath, StringBuffer, sizeof(StringBuffer)); + RtlAppendUnicodeToString(&DllPath, SharedUserData->NtSystemRoot); + RtlAppendUnicodeToString(&DllPath, L"\\System32\\"); + + if (AVrfpDebug & RTL_VRF_DBG_SHOWSNAPS) + DbgPrint("AVRF: verifier dll `%wZ'\n", &Provider->DllName); + + Status = LdrLoadDll(DllPath.Buffer, NULL, &Provider->DllName, &Provider->BaseAddress); + if (!NT_SUCCESS(Status)) + { + DbgPrint("AVRF: %wZ: failed to load provider `%wZ' (status %08X) from %wZ\n", + &LdrpImageEntry->BaseDllName, + &Provider->DllName, + Status, + &DllPath); + return Status; + } + + /* Prevent someone funny from specifying his own application as provider */ + ImageNtHeader = RtlImageNtHeader(Provider->BaseAddress); + if (!ImageNtHeader || + !(ImageNtHeader->FileHeader.Characteristics & IMAGE_FILE_DLL)) + { + DbgPrint("AVRF: provider %wZ is not a DLL image\n", &Provider->DllName); + return STATUS_DLL_INIT_FAILED; + } + + Provider->EntryPoint = LdrpFetchAddressOfEntryPoint(Provider->BaseAddress); + if (!Provider->EntryPoint) + { + DbgPrint("AVRF: cannot find an entry point for provider %wZ\n", &Provider->DllName); + return STATUS_PROCEDURE_NOT_FOUND; + } + + _SEH2_TRY + { + if (LdrpCallInitRoutine(Provider->EntryPoint, + Provider->BaseAddress, + DLL_PROCESS_VERIFIER, + &Descriptor)) + { + if (Descriptor && Descriptor->Length == sizeof(RTL_VERIFIER_PROVIDER_DESCRIPTOR)) + { + /* Copy the data */ + Provider->ProviderDlls = Descriptor->ProviderDlls; + Provider->ProviderDllLoadCallback = Descriptor->ProviderDllLoadCallback; + Provider->ProviderDllUnloadCallback = Descriptor->ProviderDllUnloadCallback; + Provider->ProviderNtdllHeapFreeCallback = Descriptor->ProviderNtdllHeapFreeCallback; + + /* Update some info for the provider */ + Descriptor->VerifierImage = LdrpImageEntry->BaseDllName.Buffer; + Descriptor->VerifierFlags = AVrfpVerifierFlags; + Descriptor->VerifierDebug = AVrfpDebug; + + /* We don't have these yet */ + DPRINT1("AVRF: RtlpGetStackTraceAddress MISSING\n"); + DPRINT1("AVRF: RtlpDebugPageHeapCreate MISSING\n"); + DPRINT1("AVRF: RtlpDebugPageHeapDestroy MISSING\n"); + Descriptor->RtlpGetStackTraceAddress = NULL; + Descriptor->RtlpDebugPageHeapCreate = NULL; + Descriptor->RtlpDebugPageHeapDestroy = NULL; + Status = STATUS_SUCCESS; + } + else + { + DbgPrint("AVRF: provider %wZ passed an invalid descriptor @ %p\n", &Provider->DllName, Descriptor); + Status = STATUS_INVALID_PARAMETER_4; + } + } + else + { + DbgPrint("AVRF: provider %wZ did not initialize correctly\n", &Provider->DllName); + Status = STATUS_DLL_INIT_FAILED; + } + } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + Status = _SEH2_GetExceptionCode(); + } + _SEH2_END; + + if (!NT_SUCCESS(Status)) + return Status; + + + if (AVrfpDebug & RTL_VRF_DBG_LISTPROVIDERS) + DbgPrint("AVRF: initialized provider %wZ (descriptor @ %p)\n", &Provider->DllName, Descriptor); + + /* Done loading providers, allow dll notifications */ + AVrfpInitialized = TRUE; + + AVrfpChainDuplicateThunks(); + AVrfpResnapInitialModules(); + + /* Manually call with DLL_PROCESS_ATTACH, since the process is not done initializing */ + _SEH2_TRY + { + if (!LdrpCallInitRoutine(Provider->EntryPoint, + Provider->BaseAddress, + DLL_PROCESS_ATTACH, + NULL)) + { + DbgPrint("AVRF: provider %wZ did not initialize correctly\n", &Provider->DllName); + Status = STATUS_DLL_INIT_FAILED; + } + + } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + Status = _SEH2_GetExceptionCode(); + } + _SEH2_END; + + return Status; +} + + +NTSTATUS +NTAPI +AVrfInitializeVerifier(VOID) +{ + NTSTATUS Status; + PVERIFIER_PROVIDER Provider; + PLIST_ENTRY Entry; + WCHAR* Ptr, *Next; + + Status = RtlInitializeCriticalSection(&AVrfpVerifierLock); + InitializeListHead(&AVrfpVerifierProvidersList); + + if (!NT_SUCCESS(Status)) + return Status; + + DbgPrint("AVRF: %wZ: pid 0x%X: flags 0x%X: application verifier enabled\n", + &LdrpImageEntry->BaseDllName, NtCurrentTeb()->ClientId.UniqueProcess, AVrfpVerifierFlags); + + Provider = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(VERIFIER_PROVIDER)); + if (!Provider) + return STATUS_NO_MEMORY; + + RtlInitUnicodeString(&Provider->DllName, L"verifier.dll"); + InsertTailList(&AVrfpVerifierProvidersList, &Provider->ListEntry); + + Next = AVrfpVerifierDllsString; + + do + { + while (*Next == L' ' || *Next == L'\t') + Next++; + + Ptr = Next; + + while (*Next != ' ' && *Next != '\t' && *Next) + Next++; + + if (*Next) + *(Next++) = '\0'; + else + Next = NULL; + + if (*Ptr) + { + Provider = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(VERIFIER_PROVIDER)); + if (!Provider) + return STATUS_NO_MEMORY; + RtlInitUnicodeString(&Provider->DllName, Ptr); + InsertTailList(&AVrfpVerifierProvidersList, &Provider->ListEntry); + } + } while (Next); + + Entry = AVrfpVerifierProvidersList.Flink; + while (Entry != &AVrfpVerifierProvidersList) + { + Provider = CONTAINING_RECORD(Entry, VERIFIER_PROVIDER, ListEntry); + Entry = Entry->Flink; + + Status = AVrfpLoadAndInitializeProvider(Provider); + if (!NT_SUCCESS(Status)) + { + RemoveEntryList(&Provider->ListEntry); + RtlFreeHeap(RtlGetProcessHeap(), 0, Provider); + } + } + + if (!NT_SUCCESS(Status)) + { + DbgPrint("AVRF: %wZ: pid 0x%X: application verifier will be disabled due to an initialization error.\n", + &LdrpImageEntry->BaseDllName, NtCurrentTeb()->ClientId.UniqueProcess); + NtCurrentPeb()->NtGlobalFlag &= ~FLG_APPLICATION_VERIFIER; + } + + return Status; +} +

6 years, 4 months

03/04: [VERIFIER] Add skeleton provider.

by Mark Jansen

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ad8a2edd850c507338e9f… commit ad8a2edd850c507338e9fe9ef186a83a81d14a44 Author: Mark Jansen <mark.jansen(a)reactos.org> AuthorDate: Fri Apr 27 00:05:21 2018 +0200 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat May 12 13:35:09 2018 +0200 [VERIFIER] Add skeleton provider. --- dll/win32/CMakeLists.txt | 1 + dll/win32/verifier/CMakeLists.txt | 12 +++ dll/win32/verifier/verifier.c | 165 ++++++++++++++++++++++++++++++ dll/win32/verifier/verifier.spec | 19 ++++ dll/win32/verifier/verifier_customstubs.c | 143 ++++++++++++++++++++++++++ 5 files changed, 340 insertions(+) diff --git a/dll/win32/CMakeLists.txt b/dll/win32/CMakeLists.txt index e4639acf65..9906d76c9c 100644 --- a/dll/win32/CMakeLists.txt +++ b/dll/win32/CMakeLists.txt @@ -222,6 +222,7 @@ add_subdirectory(userenv) add_subdirectory(usp10) add_subdirectory(uxtheme) add_subdirectory(vbscript) +add_subdirectory(verifier) add_subdirectory(version) add_subdirectory(vssapi) add_subdirectory(wbemdisp) diff --git a/dll/win32/verifier/CMakeLists.txt b/dll/win32/verifier/CMakeLists.txt new file mode 100644 index 0000000000..d41a850cdb --- /dev/null +++ b/dll/win32/verifier/CMakeLists.txt @@ -0,0 +1,12 @@ + +spec2def(verifier.dll verifier.spec) + +list(APPEND SOURCE + verifier.c + verifier_customstubs.c + ${CMAKE_CURRENT_BINARY_DIR}/verifier.def) + +add_library(verifier SHARED ${SOURCE}) +set_module_type(verifier win32dll UNICODE ENTRYPOINT DllMain 12) +add_importlibs(verifier ntdll) +add_cd_file(TARGET verifier DESTINATION reactos/system32 FOR all) diff --git a/dll/win32/verifier/verifier.c b/dll/win32/verifier/verifier.c new file mode 100644 index 0000000000..5c24bd5104 --- /dev/null +++ b/dll/win32/verifier/verifier.c @@ -0,0 +1,165 @@ +/* + * PROJECT: Application verifier + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: Main entrypoint + * COPYRIGHT: Copyright 2018 Mark Jansen (mark.jansen(a)reactos.org) + */ + +#include <ndk/rtlfuncs.h> +#include <reactos/verifier.h> + +#if 0 +#define PROVIDER_PREFIX "AVRF" +#else +#define PROVIDER_PREFIX "RVRF" +#endif + + +VOID NTAPI AVrfpDllLoadCallback(PWSTR DllName, PVOID DllBase, SIZE_T DllSize, PVOID Reserved); +VOID NTAPI AVrfpDllUnloadCallback(PWSTR DllName, PVOID DllBase, SIZE_T DllSize, PVOID Reserved); +VOID NTAPI AVrfpNtdllHeapFreeCallback(PVOID AllocationBase, SIZE_T AllocationSize); + +// DPFLTR_VERIFIER_ID + + +NTSTATUS NTAPI AVrfpLdrGetProcedureAddress(IN PVOID BaseAddress, IN PANSI_STRING Name, IN ULONG Ordinal, OUT PVOID *ProcedureAddress); + +static RTL_VERIFIER_THUNK_DESCRIPTOR AVrfpNtdllThunks[] = +{ + { "LdrGetProcedureAddress", NULL, AVrfpLdrGetProcedureAddress }, + { NULL } +}; + +FARPROC WINAPI AVrfpGetProcAddress(IN HMODULE hModule, IN LPCSTR lpProcName); + +static RTL_VERIFIER_THUNK_DESCRIPTOR AVrfpKernel32Thunks[] = +{ + { "GetProcAddress", NULL, AVrfpGetProcAddress }, + { NULL } +}; + +static RTL_VERIFIER_DLL_DESCRIPTOR AVrfpDllDescriptors[] = +{ + { L"ntdll.dll", 0, NULL, AVrfpNtdllThunks }, + { L"kernel32.dll", 0, NULL, AVrfpKernel32Thunks }, + { NULL } +}; + +RTL_VERIFIER_PROVIDER_DESCRIPTOR AVrfpProvider = +{ + /*.Length =*/ sizeof(AVrfpProvider), + /*.ProviderDlls =*/ AVrfpDllDescriptors, + /*.ProviderDllLoadCallback =*/ AVrfpDllLoadCallback, + /*.ProviderDllUnloadCallback =*/ AVrfpDllUnloadCallback, + /*.VerifierImage =*/ NULL, + /*.VerifierFlags =*/ 0, + /*.VerifierDebug =*/ 0, + /*.RtlpGetStackTraceAddress =*/ NULL, + /*.RtlpDebugPageHeapCreate =*/ NULL, + /*.RtlpDebugPageHeapDestroy =*/ NULL, + /*.ProviderNtdllHeapFreeCallback =*/ AVrfpNtdllHeapFreeCallback +}; + + + +BOOL WINAPI DllMain(HANDLE hInstance, DWORD dwReason, LPVOID lpReserved) +{ + switch (dwReason) + { + case DLL_PROCESS_ATTACH: + case DLL_PROCESS_DETACH: + case DLL_THREAD_ATTACH: + case DLL_THREAD_DETACH: + break; + case DLL_PROCESS_VERIFIER: + *(PRTL_VERIFIER_PROVIDER_DESCRIPTOR*)lpReserved = &AVrfpProvider; + break; + } + return TRUE; +} + +VOID NTAPI AVrfpDllLoadCallback(PWSTR DllName, PVOID DllBase, SIZE_T DllSize, PVOID Reserved) +{ + PLDR_DATA_TABLE_ENTRY LdrEntry = (PLDR_DATA_TABLE_ENTRY)Reserved; + DbgPrint(PROVIDER_PREFIX ": %ws @ %p: ep: %p\n", DllName, DllBase, LdrEntry->EntryPoint); + /* TODO: Hook entrypoint */ +} + + +VOID NTAPI AVrfpDllUnloadCallback(PWSTR DllName, PVOID DllBase, SIZE_T DllSize, PVOID Reserved) +{ + DbgPrint(PROVIDER_PREFIX ": unloading %ws\n", DllName); +} + +VOID NTAPI AVrfpNtdllHeapFreeCallback(PVOID AllocationBase, SIZE_T AllocationSize) +{ + DbgPrint(PROVIDER_PREFIX ": Heap free 0x%x @ %p\n", AllocationSize, AllocationBase); + /* TODO: Sanity checks */ +} + +PVOID AVrfpFindReplacementThunk(PVOID Proc) +{ + PRTL_VERIFIER_DLL_DESCRIPTOR DllDescriptor; + PRTL_VERIFIER_THUNK_DESCRIPTOR ThunkDescriptor; + + for (DllDescriptor = AVrfpDllDescriptors; DllDescriptor->DllName; ++DllDescriptor) + { + for (ThunkDescriptor = DllDescriptor->DllThunks; ThunkDescriptor->ThunkName; ++ThunkDescriptor) + { + if (ThunkDescriptor->ThunkOldAddress == Proc) + { + return ThunkDescriptor->ThunkNewAddress; + } + } + } + return Proc; +} + + +NTSTATUS NTAPI AVrfpLdrGetProcedureAddress(IN PVOID BaseAddress, IN PANSI_STRING Name, IN ULONG Ordinal, OUT PVOID *ProcedureAddress) +{ + NTSTATUS (NTAPI *oLdrGetProcedureAddress)(IN PVOID BaseAddress, IN PANSI_STRING Name, IN ULONG Ordinal, OUT PVOID *ProcedureAddress); + NTSTATUS Status; + PVOID Replacement; + + oLdrGetProcedureAddress = AVrfpNtdllThunks[0].ThunkOldAddress; + + Status = oLdrGetProcedureAddress(BaseAddress, Name, Ordinal, ProcedureAddress); + if (!NT_SUCCESS(Status)) + return Status; + + Replacement = AVrfpFindReplacementThunk(*ProcedureAddress); + if (Replacement != *ProcedureAddress) + { + *ProcedureAddress = Replacement; + if (AVrfpProvider.VerifierDebug & RTL_VRF_DBG_VERIFIER_SHOWDYNTHUNKS) + DbgPrint(PROVIDER_PREFIX ": AVrfpLdrGetProcedureAddress (%p, %Z) -> thunk address %p\n", BaseAddress, Name, *ProcedureAddress); + } + + return Status; +} + +FARPROC WINAPI AVrfpGetProcAddress(IN HMODULE hModule, IN LPCSTR lpProcName) +{ + FARPROC (WINAPI* oGetProcAddress)(IN HMODULE hModule, IN LPCSTR lpProcName); + FARPROC Proc, Replacement; + + if (AVrfpProvider.VerifierDebug & RTL_VRF_DBG_VERIFIER_LOGCALLS) + DbgPrint(PROVIDER_PREFIX ": AVrfpGetProcAddress (%p, %s)\n", hModule, lpProcName); + + oGetProcAddress = AVrfpKernel32Thunks[0].ThunkOldAddress; + Proc = oGetProcAddress(hModule, lpProcName); + if (!Proc) + return Proc; + + Replacement = AVrfpFindReplacementThunk(Proc); + if (Replacement != Proc) + { + Proc = Replacement; + if (AVrfpProvider.VerifierDebug & RTL_VRF_DBG_VERIFIER_SHOWDYNTHUNKS) + DbgPrint(PROVIDER_PREFIX ": AVrfpGetProcAddress (%p, %s) -> thunk address %p\n", hModule, lpProcName, Proc); + } + + return Proc; +} + diff --git a/dll/win32/verifier/verifier.spec b/dll/win32/verifier/verifier.spec new file mode 100644 index 0000000000..03d81b8b69 --- /dev/null +++ b/dll/win32/verifier/verifier.spec @@ -0,0 +1,19 @@ +# Do not add stubs here! + +@ stdcall VerifierAddFreeMemoryCallback(ptr) # stub +@ stdcall VerifierCreateRpcPageHeap(ptr ptr ptr ptr ptr ptr) # stub +@ stdcall VerifierDeleteFreeMemoryCallback(ptr) # stub +@ stdcall VerifierDestroyRpcPageHeap(ptr) # stub +@ stdcall VerifierDisableFaultInjectionExclusionRange(ptr) # stub +@ stdcall VerifierDisableFaultInjectionTargetRange(ptr) # stub +@ stdcall VerifierEnableFaultInjectionExclusionRange(ptr ptr) # stub +@ stdcall VerifierEnableFaultInjectionTargetRange(ptr ptr) # stub +@ stdcall VerifierEnumerateResource(ptr ptr ptr ptr ptr) # stub +@ stdcall VerifierIsCurrentThreadHoldingLocks() # stub +@ stdcall VerifierIsDllEntryActive(ptr) # stub +@ cdecl VerifierLogMessage() # stub +@ stdcall VerifierQueryRuntimeFlags(ptr ptr) # stub +@ stdcall VerifierSetFaultInjectionProbability(ptr ptr) # stub +@ stdcall VerifierSetFlags(ptr ptr ptr) # stub +@ stdcall VerifierSetRuntimeFlags(ptr) # stub +@ stdcall VerifierStopMessage(ptr ptr ptr ptr ptr ptr ptr ptr ptr ptr) # stub diff --git a/dll/win32/verifier/verifier_customstubs.c b/dll/win32/verifier/verifier_customstubs.c new file mode 100644 index 0000000000..20302b3549 --- /dev/null +++ b/dll/win32/verifier/verifier_customstubs.c @@ -0,0 +1,143 @@ +/* + * PROJECT: Application verifier + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: Custom stubs, using only ntdll functions + * COPYRIGHT: Copyright 2018 Mark Jansen (mark.jansen(a)reactos.org) + */ + +#define WIN32_NO_STATUS +#include <ndk/rtlfuncs.h> + +#define EXCEPTION_WINE_STUB 0x80000100 + +#define __wine_spec_unimplemented_stub(module, function) \ +{ \ + EXCEPTION_RECORD ExceptionRecord = {0}; \ + ExceptionRecord.ExceptionRecord = NULL; \ + ExceptionRecord.ExceptionCode = EXCEPTION_WINE_STUB; \ + ExceptionRecord.ExceptionFlags = EXCEPTION_NONCONTINUABLE; \ + ExceptionRecord.ExceptionInformation[0] = (ULONG_PTR)module; \ + ExceptionRecord.ExceptionInformation[1] = (ULONG_PTR)function; \ + ExceptionRecord.NumberParameters = 2; \ + RtlRaiseException(&ExceptionRecord); \ +} + +int NTAPI VerifierAddFreeMemoryCallback(PVOID arg0) +{ + DbgPrint("WARNING: calling stub VerifierAddFreeMemoryCallback(%p)\n", arg0); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierCreateRpcPageHeap(PVOID arg0, PVOID arg1, PVOID arg2, PVOID arg3, PVOID arg4, PVOID arg5) +{ + DbgPrint("WARNING: calling stub VerifierCreateRpcPageHeap(%p, %p, %p, %p, %p, %p)\n", arg0, arg1, arg2, arg3, arg4, arg5); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierDeleteFreeMemoryCallback(PVOID arg0) +{ + DbgPrint("WARNING: calling stub VerifierDeleteFreeMemoryCallback(%p)\n", arg0); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierDestroyRpcPageHeap(PVOID arg0) +{ + DbgPrint("WARNING: calling stub VerifierDestroyRpcPageHeap(%p)\n", arg0); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierDisableFaultInjectionExclusionRange(PVOID arg0) +{ + DbgPrint("WARNING: calling stub VerifierDisableFaultInjectionExclusionRange(%p)\n", arg0); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierDisableFaultInjectionTargetRange(PVOID arg0) +{ + DbgPrint("WARNING: calling stub VerifierDisableFaultInjectionTargetRange(%p)\n", arg0); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierEnableFaultInjectionExclusionRange(PVOID arg0, PVOID arg1) +{ + DbgPrint("WARNING: calling stub VerifierEnableFaultInjectionExclusionRange(%p, %p)\n", arg0, arg1); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierEnableFaultInjectionTargetRange(PVOID arg0, PVOID arg1) +{ + DbgPrint("WARNING: calling stub VerifierEnableFaultInjectionTargetRange(%p, %p)\n", arg0, arg1); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierEnumerateResource(PVOID arg0, PVOID arg1, PVOID arg2, PVOID arg3, PVOID arg4) +{ + DbgPrint("WARNING: calling stub VerifierEnumerateResource(%p, %p, %p, %p, %p)\n", arg0, arg1, arg2, arg3, arg4); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierIsCurrentThreadHoldingLocks() +{ + DbgPrint("WARNING: calling stub VerifierIsCurrentThreadHoldingLocks()\n"); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierIsDllEntryActive(PVOID arg0) +{ + DbgPrint("WARNING: calling stub VerifierIsDllEntryActive(%p)\n", arg0); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int __cdecl VerifierLogMessage() +{ + DbgPrint("WARNING: calling stub VerifierLogMessage()\n"); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierQueryRuntimeFlags(PVOID arg0, PVOID arg1) +{ + DbgPrint("WARNING: calling stub VerifierQueryRuntimeFlags(%p, %p)\n", arg0, arg1); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierSetFaultInjectionProbability(PVOID arg0, PVOID arg1) +{ + DbgPrint("WARNING: calling stub VerifierSetFaultInjectionProbability(%p, %p)\n", arg0, arg1); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierSetFlags(PVOID arg0, PVOID arg1, PVOID arg2) +{ + DbgPrint("WARNING: calling stub VerifierSetFlags(%p, %p, %p)\n", arg0, arg1, arg2); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierSetRuntimeFlags(PVOID arg0) +{ + DbgPrint("WARNING: calling stub VerifierSetRuntimeFlags(%p)\n", arg0); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} + +int NTAPI VerifierStopMessage(PVOID arg0, PVOID arg1, PVOID arg2, PVOID arg3, PVOID arg4, PVOID arg5, PVOID arg6, PVOID arg7, PVOID arg8, PVOID arg9) +{ + DbgPrint("WARNING: calling stub VerifierStopMessage(%p, %p, %p, %p, %p, %p, %p, %p, %p, %p)\n", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); + __wine_spec_unimplemented_stub("verifier.dll", __FUNCTION__); + return 0; +} +

6 years, 4 months

02/04: [SDK] Add initial verifier header.

by Mark Jansen

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=84d7db2c574382b5d6385… commit 84d7db2c574382b5d63859a9670cd0c5633f241a Author: Mark Jansen <mark.jansen(a)reactos.org> AuthorDate: Fri Apr 27 00:05:06 2018 +0200 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat May 12 13:34:36 2018 +0200 [SDK] Add initial verifier header. --- sdk/include/reactos/verifier.h | 86 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+) diff --git a/sdk/include/reactos/verifier.h b/sdk/include/reactos/verifier.h new file mode 100644 index 0000000000..b0e8413d15 --- /dev/null +++ b/sdk/include/reactos/verifier.h @@ -0,0 +1,86 @@ +#ifndef REACTOS_VERIFIER_H +#define REACTOS_VERIFIER_H + +#define DLL_PROCESS_VERIFIER 4 + +typedef VOID (NTAPI* RTL_VERIFIER_DLL_LOAD_CALLBACK) (PWSTR DllName, PVOID DllBase, SIZE_T DllSize, PVOID Reserved); +typedef VOID (NTAPI* RTL_VERIFIER_DLL_UNLOAD_CALLBACK) (PWSTR DllName, PVOID DllBase, SIZE_T DllSize, PVOID Reserved); +typedef VOID (NTAPI* RTL_VERIFIER_NTDLLHEAPFREE_CALLBACK) (PVOID AllocationBase, SIZE_T AllocationSize); + +typedef struct _RTL_VERIFIER_THUNK_DESCRIPTOR { + PCHAR ThunkName; + PVOID ThunkOldAddress; + PVOID ThunkNewAddress; +} RTL_VERIFIER_THUNK_DESCRIPTOR, *PRTL_VERIFIER_THUNK_DESCRIPTOR; + +typedef struct _RTL_VERIFIER_DLL_DESCRIPTOR { + PWCHAR DllName; + DWORD DllFlags; + PVOID DllAddress; + PRTL_VERIFIER_THUNK_DESCRIPTOR DllThunks; +} RTL_VERIFIER_DLL_DESCRIPTOR, *PRTL_VERIFIER_DLL_DESCRIPTOR; + +typedef struct _RTL_VERIFIER_PROVIDER_DESCRIPTOR { + // Provider fields + DWORD Length; + PRTL_VERIFIER_DLL_DESCRIPTOR ProviderDlls; + RTL_VERIFIER_DLL_LOAD_CALLBACK ProviderDllLoadCallback; + RTL_VERIFIER_DLL_UNLOAD_CALLBACK ProviderDllUnloadCallback; + + // Verifier fields + PWSTR VerifierImage; + DWORD VerifierFlags; + DWORD VerifierDebug; + PVOID RtlpGetStackTraceAddress; + PVOID RtlpDebugPageHeapCreate; + PVOID RtlpDebugPageHeapDestroy; + + // Provider field + RTL_VERIFIER_NTDLLHEAPFREE_CALLBACK ProviderNtdllHeapFreeCallback; +} RTL_VERIFIER_PROVIDER_DESCRIPTOR, *PRTL_VERIFIER_PROVIDER_DESCRIPTOR; + + +// VerifierFlags + +#define RTL_VRF_FLG_FULL_PAGE_HEAP 0x00000001 +#define RTL_VRF_FLG_RESERVED_DONOTUSE 0x00000002 +#define RTL_VRF_FLG_HANDLE_CHECKS 0x00000004 +#define RTL_VRF_FLG_STACK_CHECKS 0x00000008 +#define RTL_VRF_FLG_APPCOMPAT_CHECKS 0x00000010 +#define RTL_VRF_FLG_TLS_CHECKS 0x00000020 +#define RTL_VRF_FLG_DIRTY_STACKS 0x00000040 +#define RTL_VRF_FLG_RPC_CHECKS 0x00000080 +#define RTL_VRF_FLG_COM_CHECKS 0x00000100 +#define RTL_VRF_FLG_DANGEROUS_APIS 0x00000200 +#define RTL_VRF_FLG_RACE_CHECKS 0x00000400 +#define RTL_VRF_FLG_DEADLOCK_CHECKS 0x00000800 +#define RTL_VRF_FLG_FIRST_CHANCE_EXCEPTION_CHECKS 0x00001000 +#define RTL_VRF_FLG_VIRTUAL_MEM_CHECKS 0x00002000 +#define RTL_VRF_FLG_ENABLE_LOGGING 0x00004000 +#define RTL_VRF_FLG_FAST_FILL_HEAP 0x00008000 +#define RTL_VRF_FLG_VIRTUAL_SPACE_TRACKING 0x00010000 +#define RTL_VRF_FLG_ENABLED_SYSTEM_WIDE 0x00020000 +#define RTL_VRF_FLG_MISCELLANEOUS_CHECKS 0x00020000 +#define RTL_VRF_FLG_LOCK_CHECKS 0x00040000 + + +// VerifierDebug + +#define RTL_VRF_DBG_SHOWSNAPS 0x00001 +#define RTL_VRF_DBG_SHOWFOUNDEXPORTS 0x00002 +#define RTL_VRF_DBG_SHOWVERIFIEDEXPORTS 0x00004 +#define RTL_VRF_DBG_LISTPROVIDERS 0x00008 +#define RTL_VRF_DBG_SHOWCHAINING 0x00010 +#define RTL_VRF_DBG_SHOWCHAINING_DEBUG 0x00020 + +#define RTL_VRF_DBG_CS_SPLAYTREE 0x00200 +#define RTL_VRF_DBG_CS_DUMP_SPLAYTREE 0x00400 +#define RTL_VRF_DBG_CS_CREATE_DELETE 0x00800 + +#define RTL_VRF_DBG_VERIFIER_LOGCALLS 0x04000 +#define RTL_VRF_DBG_VERIFIER_SHOWDYNTHUNKS 0x08000 + +#define RTL_VRF_DBG_ENTRYPOINT_HOOKS 0x10000 +#define RTL_VRF_DBG_ENTRYPOINT_CALLS 0x20000 + +#endif // REACTOS_VERIFIER_H

6 years, 4 months

01/04: [SDK] Correct NtGlobalFlag names.

by Mark Jansen

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=5a68fbeb43bd9c5ddbff3… commit 5a68fbeb43bd9c5ddbff3b83b82815f842b03e02 Author: Mark Jansen <mark.jansen(a)reactos.org> AuthorDate: Thu Apr 26 22:54:23 2018 +0200 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat May 12 13:34:24 2018 +0200 [SDK] Correct NtGlobalFlag names. --- dll/ntdll/ldr/ldrinit.c | 6 +++--- sdk/include/ndk/pstypes.h | 3 +-- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/dll/ntdll/ldr/ldrinit.c b/dll/ntdll/ldr/ldrinit.c index 5162f1afed..a5655eca41 100644 --- a/dll/ntdll/ldr/ldrinit.c +++ b/dll/ntdll/ldr/ldrinit.c @@ -1424,7 +1424,7 @@ LdrpInitializeExecutionOptions(PUNICODE_STRING ImagePathName, PPEB Peb, PHANDLE GlobalFlag = 0; /* Call AVRF if necessary */ - if (Peb->NtGlobalFlag & (FLG_POOL_ENABLE_TAIL_CHECK | FLG_HEAP_PAGE_ALLOCS)) + if (Peb->NtGlobalFlag & (FLG_APPLICATION_VERIFIER | FLG_HEAP_PAGE_ALLOCS)) { Status = LdrpInitializeApplicationVerifierPackage(ImagePathName, Peb, TRUE, FALSE); if (!NT_SUCCESS(Status)) @@ -1436,7 +1436,7 @@ LdrpInitializeExecutionOptions(PUNICODE_STRING ImagePathName, PPEB Peb, PHANDLE else { /* There are no image-specific options, so perform global initialization */ - if (Peb->NtGlobalFlag & (FLG_POOL_ENABLE_TAIL_CHECK | FLG_HEAP_PAGE_ALLOCS)) + if (Peb->NtGlobalFlag & (FLG_APPLICATION_VERIFIER | FLG_HEAP_PAGE_ALLOCS)) { /* Initialize app verifier package */ Status = LdrpInitializeApplicationVerifierPackage(ImagePathName, Peb, TRUE, FALSE); @@ -2055,7 +2055,7 @@ LdrpInitializeProcess(IN PCONTEXT Context, } /* Check if the Application Verifier was enabled */ - if (Peb->NtGlobalFlag & FLG_POOL_ENABLE_TAIL_CHECK) + if (Peb->NtGlobalFlag & FLG_APPLICATION_VERIFIER) { /* FIXME */ DPRINT1("We don't support Application Verifier yet\n"); diff --git a/sdk/include/ndk/pstypes.h b/sdk/include/ndk/pstypes.h index 0b6e160922..01468b2eb9 100644 --- a/sdk/include/ndk/pstypes.h +++ b/sdk/include/ndk/pstypes.h @@ -61,8 +61,7 @@ extern POBJECT_TYPE NTSYSAPI PsJobType; #define FLG_HEAP_ENABLE_FREE_CHECK 0x00000020 #define FLG_HEAP_VALIDATE_PARAMETERS 0x00000040 #define FLG_HEAP_VALIDATE_ALL 0x00000080 -#define FLG_POOL_ENABLE_TAIL_CHECK 0x00000100 -#define FLG_POOL_ENABLE_FREE_CHECK 0x00000200 +#define FLG_APPLICATION_VERIFIER 0x00000100 #define FLG_POOL_ENABLE_TAGGING 0x00000400 #define FLG_HEAP_ENABLE_TAGGING 0x00000800 #define FLG_USER_STACK_TRACE_DB 0x00001000

6 years, 4 months

02/02: [SETUPAPI] SetupDiCallClassInstaller: Use the class GUID enclosed in curly brackets as a sub key name to retrieve the class co-installer.

by Eric Kohl

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=35bd6571bd423d2ac4b86… commit 35bd6571bd423d2ac4b86e2db797bddcd98d05c5 Author: Eric Kohl <eric.kohl(a)reactos.org> AuthorDate: Sat May 12 12:42:56 2018 +0200 Commit: Eric Kohl <eric.kohl(a)reactos.org> CommitDate: Sat May 12 12:42:56 2018 +0200 [SETUPAPI] SetupDiCallClassInstaller: Use the class GUID enclosed in curly brackets as a sub key name to retrieve the class co-installer. --- dll/win32/setupapi/devinst.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/dll/win32/setupapi/devinst.c b/dll/win32/setupapi/devinst.c index 1d83664bf2..2aaa4962e2 100644 --- a/dll/win32/setupapi/devinst.c +++ b/dll/win32/setupapi/devinst.c @@ -4288,16 +4288,16 @@ BOOL WINAPI SetupDiCallClassInstaller( &hKey); if (rc == ERROR_SUCCESS) { - LPWSTR lpGuidString; - if (UuidToStringW((UUID*)&DeviceInfoData->ClassGuid, &lpGuidString) == RPC_S_OK) + WCHAR szGuidString[40]; + if (pSetupStringFromGuid(&DeviceInfoData->ClassGuid, szGuidString, ARRAYSIZE(szGuidString)) == ERROR_SUCCESS) { - rc = RegQueryValueExW(hKey, lpGuidString, NULL, &dwRegType, NULL, &dwLength); + rc = RegQueryValueExW(hKey, szGuidString, NULL, &dwRegType, NULL, &dwLength); if (rc == ERROR_SUCCESS && dwRegType == REG_MULTI_SZ) { LPWSTR KeyBuffer = HeapAlloc(GetProcessHeap(), 0, dwLength); if (KeyBuffer != NULL) { - rc = RegQueryValueExW(hKey, lpGuidString, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength); + rc = RegQueryValueExW(hKey, szGuidString, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength); if (rc == ERROR_SUCCESS) { LPWSTR ptr; @@ -4319,7 +4319,6 @@ BOOL WINAPI SetupDiCallClassInstaller( HeapFree(GetProcessHeap(), 0, KeyBuffer); } } - RpcStringFreeW(&lpGuidString); } RegCloseKey(hKey); }

6 years, 4 months

01/02: [BOOTDATA] Register the CriticalDeviceCoInstaller for the keyboard device class

by Eric Kohl

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=abf9bd2d68131a94a57f2… commit abf9bd2d68131a94a57f2a31ee82dbc97c705181 Author: Eric Kohl <eric.kohl(a)reactos.org> AuthorDate: Sat May 12 12:38:27 2018 +0200 Commit: Eric Kohl <eric.kohl(a)reactos.org> CommitDate: Sat May 12 12:38:27 2018 +0200 [BOOTDATA] Register the CriticalDeviceCoInstaller for the keyboard device class --- boot/bootdata/hivesys.inf | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/boot/bootdata/hivesys.inf b/boot/bootdata/hivesys.inf index 5fe7b84ce3..038beb96a4 100644 --- a/boot/bootdata/hivesys.inf +++ b/boot/bootdata/hivesys.inf @@ -384,6 +384,11 @@ HKLM,"SYSTEM\CurrentControlSet\Control\Class\{9D6D66A6-0B0C-4563-9077-A0E9A7955A HKLM,"SYSTEM\CurrentControlSet\Control\Class\{9D6D66A6-0B0C-4563-9077-A0E9A7955AE4}","Class",0x00000000,"Ramdisk" HKLM,"SYSTEM\CurrentControlSet\Control\Class\{9D6D66A6-0B0C-4563-9077-A0E9A7955AE4}","Icon",0x00000000,"-5" +; Class Co-Installers +HKLM,"SYSTEM\CurrentControlSet\Control\CoDeviceInstallers",,0x00000012 +HKLM,"SYSTEM\CurrentControlSet\Control\CoDeviceInstallers","{4D36E96B-E325-11CE-BFC1-08002BE10318}",0x00010000,"syssetup.dll,CriticalDeviceCoInstaller" + + ; Default computer name settings HKLM,"SYSTEM\CurrentControlSet\Control\ComputerName",,0x00000012 HKLM,"SYSTEM\CurrentControlSet\Control\ComputerName\ComputerName","ComputerName",0x00000002,"COMPUTERNAME"

6 years, 4 months

01/01: [FASTFAT] Implement support for stack overflow in read operations.

by Pierre Schweitzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=38078335b9ab4c5f8e8f6… commit 38078335b9ab4c5f8e8f6f37dba5c251de5fa02a Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Sat May 12 12:00:09 2018 +0200 Commit: Pierre Schweitzer <pierre(a)reactos.org> CommitDate: Sat May 12 12:03:18 2018 +0200 [FASTFAT] Implement support for stack overflow in read operations. Before performing a read operation, FastFAT driver will attempt to compute whether it would run out of stack during the operation. If so, instead of attempting the operation in the current thread, it will post the read request to the overflow thread. This should help with the regressions brought in by 94ead99e0c503faa40b33b813cce296ea5c0bc0c. CORE-14601 --- drivers/filesystems/fastfat/rw.c | 279 ++++++++++++++++++++++++++------------- 1 file changed, 187 insertions(+), 92 deletions(-) diff --git a/drivers/filesystems/fastfat/rw.c b/drivers/filesystems/fastfat/rw.c index 4dd59933c4..76ffff933c 100644 --- a/drivers/filesystems/fastfat/rw.c +++ b/drivers/filesystems/fastfat/rw.c @@ -1,9 +1,10 @@ /* * COPYRIGHT: See COPYING in the top level directory * PROJECT: ReactOS kernel - * FILE: drivers/fs/vfat/rw.c + * FILE: drivers/filesystems/fastfat/rw.c * PURPOSE: VFAT Filesystem * PROGRAMMER: Jason Filby (jasonfilby(a)yahoo.com) + * Pierre Schweitzer (pierre(a)reactos.org) * */ @@ -23,6 +24,12 @@ */ /* #define DEBUG_VERIFY_OFFSET_CACHING */ +/* Arbitrary, taken from MS FastFAT, should be + * refined given what we experience in common + * out of stack operations + */ +#define OVERFLOW_READ_THRESHHOLD 0xE00 + /* FUNCTIONS *****************************************************************/ /* @@ -535,6 +542,169 @@ VfatWriteFileData( return Status; } +NTSTATUS +VfatCommonRead( + PVFAT_IRP_CONTEXT IrpContext) +{ + PVFATFCB Fcb; + PVOID Buffer; + NTSTATUS Status; + ULONG Length = 0; + ULONG BytesPerSector; + LARGE_INTEGER ByteOffset; + ULONG ReturnedLength = 0; + BOOLEAN PagingIo, CanWait, IsVolume, NoCache; + + PagingIo = BooleanFlagOn(IrpContext->Irp->Flags, IRP_PAGING_IO); + CanWait = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT); + NoCache = BooleanFlagOn(IrpContext->Irp->Flags, IRP_NOCACHE); + Fcb = IrpContext->FileObject->FsContext; + IsVolume = BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME); + + ByteOffset = IrpContext->Stack->Parameters.Read.ByteOffset; + Length = IrpContext->Stack->Parameters.Read.Length; + BytesPerSector = IrpContext->DeviceExt->FatInfo.BytesPerSector; + + if (!PagingIo && + FsRtlAreThereCurrentFileLocks(&Fcb->FileLock)) + { + if (!FsRtlCheckLockForReadAccess(&Fcb->FileLock, IrpContext->Irp)) + { + return STATUS_FILE_LOCK_CONFLICT; + } + } + + Buffer = VfatGetUserBuffer(IrpContext->Irp, PagingIo); + + if (!PagingIo && !NoCache && !IsVolume) + { + // cached read + Status = STATUS_SUCCESS; + if (ByteOffset.u.LowPart + Length > Fcb->RFCB.FileSize.u.LowPart) + { + Length = Fcb->RFCB.FileSize.u.LowPart - ByteOffset.u.LowPart; + Status = /*STATUS_END_OF_FILE*/STATUS_SUCCESS; + } + + vfatAddToStat(IrpContext->DeviceExt, Base.UserFileReads, 1); + vfatAddToStat(IrpContext->DeviceExt, Base.UserFileReadBytes, Length); + + _SEH2_TRY + { + if (IrpContext->FileObject->PrivateCacheMap == NULL) + { + CcInitializeCacheMap(IrpContext->FileObject, + (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize), + FALSE, + &(VfatGlobalData->CacheMgrCallbacks), + Fcb); + } + + if (!CcCopyRead(IrpContext->FileObject, + &ByteOffset, + Length, + CanWait, + Buffer, + &IrpContext->Irp->IoStatus)) + { + ASSERT(!CanWait); + Status = STATUS_PENDING; + goto ByeBye; + } + } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + Status = _SEH2_GetExceptionCode(); + goto ByeBye; + } + _SEH2_END; + + if (!NT_SUCCESS(IrpContext->Irp->IoStatus.Status)) + { + Status = IrpContext->Irp->IoStatus.Status; + } + } + else + { + // non cached read + Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoWriteAccess); + if (!NT_SUCCESS(Status)) + { + goto ByeBye; + } + + if (ByteOffset.QuadPart + Length > ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector)) + { + Length = (ULONG)(ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector) - ByteOffset.QuadPart); + } + + if (!IsVolume) + { + vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedReads, 1); + vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedReadBytes, Length); + } + else + { + vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataReads, 1); + vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataReadBytes, Length); + } + + Status = VfatReadFileData(IrpContext, Length, ByteOffset, &ReturnedLength); + if (NT_SUCCESS(Status)) + { + IrpContext->Irp->IoStatus.Information = ReturnedLength; + } + } + +ByeBye: + return Status; +} + +VOID +NTAPI +VfatStackOverflowRead( + PVOID Context, + IN PKEVENT Event) +{ + PVFAT_IRP_CONTEXT IrpContext; + + IrpContext = Context; + /* In a separate thread, we can wait and resources got locked */ + SetFlag(IrpContext->Flags, IRPCONTEXT_CANWAIT); + + /* Perform the read operation */ + DPRINT1("Performing posted read\n"); + VfatCommonRead(IrpContext); + + KeSetEvent(Event, 0, FALSE); +} + +VOID +VfatPostRead( + PVFAT_IRP_CONTEXT IrpContext, + PERESOURCE Lock, + BOOLEAN PagingIo) +{ + KEVENT Event; + + KeInitializeEvent(&Event, NotificationEvent, FALSE); + + ExAcquireResourceSharedLite(Lock, TRUE); + + /* If paging IO, call the non failing but blocking routine */ + if (PagingIo) + { + FsRtlPostPagingFileStackOverflow(IrpContext, &Event, VfatStackOverflowRead); + } + else + { + FsRtlPostStackOverflow(IrpContext, &Event, VfatStackOverflowRead); + } + + /* Wait till it's done */ + KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL); +} + NTSTATUS VfatRead( PVFAT_IRP_CONTEXT IrpContext) @@ -542,10 +712,8 @@ VfatRead( NTSTATUS Status; PVFATFCB Fcb; ULONG Length = 0; - ULONG ReturnedLength = 0; PERESOURCE Resource = NULL; LARGE_INTEGER ByteOffset; - PVOID Buffer; ULONG BytesPerSector; BOOLEAN PagingIo, CanWait, IsVolume, NoCache; @@ -644,105 +812,32 @@ VfatRead( Resource = &Fcb->MainResource; } - if (!ExAcquireResourceSharedLite(Resource, CanWait)) - { - Resource = NULL; - Status = STATUS_PENDING; - goto ByeBye; - } - - if (!PagingIo && - FsRtlAreThereCurrentFileLocks(&Fcb->FileLock)) - { - if (!FsRtlCheckLockForReadAccess(&Fcb->FileLock, IrpContext->Irp)) - { - Status = STATUS_FILE_LOCK_CONFLICT; - goto ByeBye; - } - } - - Buffer = VfatGetUserBuffer(IrpContext->Irp, PagingIo); - - if (!PagingIo && !NoCache && !IsVolume) - { - // cached read - Status = STATUS_SUCCESS; - if (ByteOffset.u.LowPart + Length > Fcb->RFCB.FileSize.u.LowPart) - { - Length = Fcb->RFCB.FileSize.u.LowPart - ByteOffset.u.LowPart; - Status = /*STATUS_END_OF_FILE*/STATUS_SUCCESS; - } - - vfatAddToStat(IrpContext->DeviceExt, Base.UserFileReads, 1); - vfatAddToStat(IrpContext->DeviceExt, Base.UserFileReadBytes, Length); - - _SEH2_TRY - { - if (IrpContext->FileObject->PrivateCacheMap == NULL) - { - CcInitializeCacheMap(IrpContext->FileObject, - (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize), - FALSE, - &(VfatGlobalData->CacheMgrCallbacks), - Fcb); - } - - if (!CcCopyRead(IrpContext->FileObject, - &ByteOffset, - Length, - CanWait, - Buffer, - &IrpContext->Irp->IoStatus)) - { - ASSERT(!CanWait); - Status = STATUS_PENDING; - goto ByeBye; - } - } - _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) - { - Status = _SEH2_GetExceptionCode(); - goto ByeBye; - } - _SEH2_END; - - if (!NT_SUCCESS(IrpContext->Irp->IoStatus.Status)) - { - Status = IrpContext->Irp->IoStatus.Status; - } - } - else + /* Are we out of stack for the rest of the operation? */ + if (IoGetRemainingStackSize() < OVERFLOW_READ_THRESHHOLD) { - // non cached read + /* Lock the buffer */ Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoWriteAccess); if (!NT_SUCCESS(Status)) { - goto ByeBye; + return Status; } - if (ByteOffset.QuadPart + Length > ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector)) - { - Length = (ULONG)(ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector) - ByteOffset.QuadPart); - } + /* And post the read to the overflow thread */ + VfatPostRead(IrpContext, Resource, PagingIo); - if (!IsVolume) - { - vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedReads, 1); - vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedReadBytes, Length); - } - else - { - vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataReads, 1); - vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataReadBytes, Length); - } + /* Return the appropriate status */ + return IrpContext->Irp->IoStatus.Status; + } - Status = VfatReadFileData(IrpContext, Length, ByteOffset, &ReturnedLength); - if (NT_SUCCESS(Status)) - { - IrpContext->Irp->IoStatus.Information = ReturnedLength; - } + if (!ExAcquireResourceSharedLite(Resource, CanWait)) + { + Resource = NULL; + Status = STATUS_PENDING; + goto ByeBye; } + Status = VfatCommonRead(IrpContext); + ByeBye: if (Resource) {

6 years, 4 months

01/01: [USBPORT] Fix x64 build.

by Thomas Faber

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=0ce31759d068b6f8dda7e… commit 0ce31759d068b6f8dda7eb79a9ecdd16c598a25e Author: Thomas Faber <thomas.faber(a)reactos.org> AuthorDate: Sat May 12 09:42:52 2018 +0200 Commit: Thomas Faber <thomas.faber(a)reactos.org> CommitDate: Sat May 12 10:11:21 2018 +0200 [USBPORT] Fix x64 build. --- drivers/usb/usbport/usbport.h | 4 ++-- sdk/include/reactos/drivers/usbport/usbmport.h | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/drivers/usb/usbport/usbport.h b/drivers/usb/usbport/usbport.h index d09edb1b31..6ec826afed 100644 --- a/drivers/usb/usbport/usbport.h +++ b/drivers/usb/usbport/usbport.h @@ -394,7 +394,7 @@ typedef struct _USBPORT_DEVICE_EXTENSION { #if !defined(_M_X64) ULONG Padded[64]; #else - ULONG Padded[0]; + ULONG Padded[30]; #endif } USBPORT_DEVICE_EXTENSION, *PUSBPORT_DEVICE_EXTENSION; @@ -402,7 +402,7 @@ typedef struct _USBPORT_DEVICE_EXTENSION { #if !defined(_M_X64) C_ASSERT(sizeof(USBPORT_DEVICE_EXTENSION) == 0x500); #else -C_ASSERT(sizeof(USBPORT_DEVICE_EXTENSION) == 0x690); +C_ASSERT(sizeof(USBPORT_DEVICE_EXTENSION) == 0x700); #endif typedef struct _USBPORT_RH_DESCRIPTORS { diff --git a/sdk/include/reactos/drivers/usbport/usbmport.h b/sdk/include/reactos/drivers/usbport/usbmport.h index 0b1387179e..a646eb1ab4 100644 --- a/sdk/include/reactos/drivers/usbport/usbmport.h +++ b/sdk/include/reactos/drivers/usbport/usbmport.h @@ -51,9 +51,9 @@ typedef struct _USBPORT_RESOURCES { BOOLEAN ShareVector; UCHAR Padded2[3]; KINTERRUPT_MODE InterruptMode; - ULONG Reserved; + ULONG_PTR Reserved; PVOID ResourceBase; - SIZE_T IoSpaceLength; + ULONG IoSpaceLength; ULONG_PTR StartVA; ULONG StartPA; UCHAR LegacySupport; @@ -62,7 +62,7 @@ typedef struct _USBPORT_RESOURCES { UCHAR Reserved3; } USBPORT_RESOURCES, *PUSBPORT_RESOURCES; -C_ASSERT(sizeof(USBPORT_RESOURCES) == 24 + 7 * sizeof(PVOID)); +C_ASSERT(sizeof(USBPORT_RESOURCES) == 32 + 5 * sizeof(PVOID)); typedef struct _USBPORT_ENDPOINT_PROPERTIES { USHORT DeviceAddress; @@ -90,7 +90,7 @@ typedef struct _USBPORT_ENDPOINT_PROPERTIES { ULONG Reserved6; } USBPORT_ENDPOINT_PROPERTIES, *PUSBPORT_ENDPOINT_PROPERTIES; -C_ASSERT(sizeof(USBPORT_ENDPOINT_PROPERTIES) == 48 + 4 * sizeof(PVOID)); +C_ASSERT(sizeof(USBPORT_ENDPOINT_PROPERTIES) == 56 + 2 * sizeof(PVOID)); typedef struct _USBPORT_TRANSFER_PARAMETERS { ULONG TransferFlags;

6 years, 4 months

01/01: [INETCPL] Fix a typo in Romanian resource file

by Bișoc George

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=337e7322a659134e84d25… commit 337e7322a659134e84d25295cff90c52f1591dcf Author: Bișoc George <fraizeraust99(a)gmail.com> AuthorDate: Fri May 11 20:28:44 2018 +0200 Commit: Hermès BÉLUSCA - MAÏTO <hermes.belusca-maito(a)reactos.org> CommitDate: Fri May 11 23:34:52 2018 +0200 [INETCPL] Fix a typo in Romanian resource file --- dll/cpl/inetcpl/lang/ro-RO.rc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dll/cpl/inetcpl/lang/ro-RO.rc b/dll/cpl/inetcpl/lang/ro-RO.rc index 37d6127db3..aae5f967cb 100644 --- a/dll/cpl/inetcpl/lang/ro-RO.rc +++ b/dll/cpl/inetcpl/lang/ro-RO.rc @@ -66,7 +66,7 @@ FONT 8, "MS Shell Dlg" CAPTION "Eliminare istoric de navigare" BEGIN - AUTOCHECKBOX "Fișierele de internet t&emporare\nCópii ale paginilor temporar stocate, imagini și certificate.", + AUTOCHECKBOX "Fișierele de internet t&emporare\nCopii ale paginilor temporar stocate, imagini și certificate.", IDC_DELETE_TEMP_FILES, 10, 8, 230, 40, BS_TOP | BS_MULTILINE AUTOCHECKBOX "Informațiile de &conexiune (Cookies)\nFișiere cu date precum informații de autentificare sau preferințe, stocate în calculatorul dumneavoastră din paginile vizitate.", IDC_DELETE_COOKIES, 10, 48, 230, 40, BS_TOP | BS_MULTILINE

6 years, 4 months

02/02: [USBPORT][USBOHCI_NEW] Avoid using pointers for physical addresses.

by Vadim Galyant

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c89a190ea655b030f4cc9… commit c89a190ea655b030f4cc91de8b47ead424e9d339 Author: Vadim Galyant <vgal(a)rambler.ru> AuthorDate: Fri May 11 15:34:49 2018 +0200 Commit: Thomas Faber <thomas.faber(a)reactos.org> CommitDate: Fri May 11 15:46:25 2018 +0200 [USBPORT][USBOHCI_NEW] Avoid using pointers for physical addresses. --- drivers/usb/usbohci_new/usbohci.c | 12 ++++++------ drivers/usb/usbport/pnp.c | 4 ++-- drivers/usb/usbport/power.c | 2 +- drivers/usb/usbport/usbport.c | 6 +++--- drivers/usb/usbport/usbport.h | 2 +- sdk/include/reactos/drivers/usbport/usbmport.h | 8 ++++---- 6 files changed, 17 insertions(+), 17 deletions(-) diff --git a/drivers/usb/usbohci_new/usbohci.c b/drivers/usb/usbohci_new/usbohci.c index 87c3c13838..ef123288b2 100644 --- a/drivers/usb/usbohci_new/usbohci.c +++ b/drivers/usb/usbohci_new/usbohci.c @@ -672,8 +672,8 @@ OHCI_StartController(IN PVOID ohciExtension, return MPStatus; } - OhciExtension->HcResourcesVA = Resources->StartVA; - OhciExtension->HcResourcesPA = Resources->StartPA; + OhciExtension->HcResourcesVA = (POHCI_HC_RESOURCES)Resources->StartVA; + OhciExtension->HcResourcesPA = (POHCI_HC_RESOURCES)Resources->StartPA; DPRINT_OHCI("OHCI_StartController: HcResourcesVA - %p, HcResourcesPA - %p\n", OhciExtension->HcResourcesVA, @@ -1731,9 +1731,9 @@ OHCI_AbortTransfer(IN PVOID ohciExtension, ED = OhciEndpoint->HcdED; NextTdPA = ED->HwED.HeadPointer & OHCI_ED_HEAD_POINTER_MASK; - NextTD = RegPacket.UsbPortGetMappedVirtualAddress((PVOID)NextTdPA, - OhciExtension, - OhciEndpoint); + NextTD = RegPacket.UsbPortGetMappedVirtualAddress(NextTdPA, + OhciExtension, + OhciEndpoint); if (NextTD->OhciTransfer == (ULONG)OhciTransfer) { @@ -1978,7 +1978,7 @@ OHCI_PollAsyncEndpoint(IN POHCI_EXTENSION OhciExtension, DbgBreakPoint(); } - NextTD = RegPacket.UsbPortGetMappedVirtualAddress((PVOID)NextTdPA, + NextTD = RegPacket.UsbPortGetMappedVirtualAddress(NextTdPA, OhciExtension, OhciEndpoint); DPRINT_OHCI("NextTD - %p\n", NextTD); diff --git a/drivers/usb/usbport/pnp.c b/drivers/usb/usbport/pnp.c index 7b0c5dd20e..52c649e9b5 100644 --- a/drivers/usb/usbport/pnp.c +++ b/drivers/usb/usbport/pnp.c @@ -824,8 +824,8 @@ USBPORT_StartDevice(IN PDEVICE_OBJECT FdoDevice, goto ExitWithError; } - UsbPortResources->StartVA = (PVOID)HeaderBuffer->VirtualAddress; - UsbPortResources->StartPA = (PVOID)HeaderBuffer->PhysicalAddress; + UsbPortResources->StartVA = HeaderBuffer->VirtualAddress; + UsbPortResources->StartPA = HeaderBuffer->PhysicalAddress; FdoExtension->MiniPortCommonBuffer = HeaderBuffer; } diff --git a/drivers/usb/usbport/power.c b/drivers/usb/usbport/power.c index 0dca45334d..9fcb2aa5e6 100644 --- a/drivers/usb/usbport/power.c +++ b/drivers/usb/usbport/power.c @@ -197,7 +197,7 @@ USBPORT_ResumeController(IN PDEVICE_OBJECT FdoDevice) RtlZeroMemory(FdoExtension->MiniPortExt, Packet->MiniPortExtensionSize); - RtlZeroMemory(FdoExtension->UsbPortResources.StartVA, + RtlZeroMemory((PVOID)FdoExtension->UsbPortResources.StartVA, Packet->MiniPortResourcesSize); FdoExtension->UsbPortResources.IsChirpHandled = TRUE; diff --git a/drivers/usb/usbport/usbport.c b/drivers/usb/usbport/usbport.c index cc85e73bca..9961063209 100644 --- a/drivers/usb/usbport/usbport.c +++ b/drivers/usb/usbport/usbport.c @@ -1696,7 +1696,7 @@ USBPORT_AllocateCommonBuffer(IN PDEVICE_OBJECT FdoDevice, PHYSICAL_ADDRESS LogicalAddress; ULONG_PTR BaseVA; ULONG_PTR StartBufferVA; - ULONG_PTR StartBufferPA; + ULONG StartBufferPA; DPRINT("USBPORT_AllocateCommonBuffer: FdoDevice - %p, BufferLength - %p\n", FdoDevice, @@ -2108,7 +2108,7 @@ USBPORT_RequestAsyncCallback(IN PVOID MiniPortExtension, PVOID NTAPI -USBPORT_GetMappedVirtualAddress(IN PVOID PhysicalAddress, +USBPORT_GetMappedVirtualAddress(IN ULONG PhysicalAddress, IN PVOID MiniPortExtension, IN PVOID MiniPortEndpoint) { @@ -2129,7 +2129,7 @@ USBPORT_GetMappedVirtualAddress(IN PVOID PhysicalAddress, HeaderBuffer = Endpoint->HeaderBuffer; - Offset = (ULONG_PTR)PhysicalAddress - HeaderBuffer->PhysicalAddress; + Offset = PhysicalAddress - HeaderBuffer->PhysicalAddress; VirtualAddress = HeaderBuffer->VirtualAddress + Offset; return (PVOID)VirtualAddress; diff --git a/drivers/usb/usbport/usbport.h b/drivers/usb/usbport/usbport.h index 7895b97bde..d09edb1b31 100644 --- a/drivers/usb/usbport/usbport.h +++ b/drivers/usb/usbport/usbport.h @@ -148,7 +148,7 @@ typedef struct _USBPORT_COMMON_BUFFER_HEADER { PHYSICAL_ADDRESS LogicalAddress; SIZE_T BufferLength; ULONG_PTR VirtualAddress; - ULONG_PTR PhysicalAddress; + ULONG PhysicalAddress; } USBPORT_COMMON_BUFFER_HEADER, *PUSBPORT_COMMON_BUFFER_HEADER; typedef struct _USBPORT_ENDPOINT *PUSBPORT_ENDPOINT; diff --git a/sdk/include/reactos/drivers/usbport/usbmport.h b/sdk/include/reactos/drivers/usbport/usbmport.h index 23a7e91e9a..0b1387179e 100644 --- a/sdk/include/reactos/drivers/usbport/usbmport.h +++ b/sdk/include/reactos/drivers/usbport/usbmport.h @@ -54,8 +54,8 @@ typedef struct _USBPORT_RESOURCES { ULONG Reserved; PVOID ResourceBase; SIZE_T IoSpaceLength; - PVOID StartVA; - PVOID StartPA; + ULONG_PTR StartVA; + ULONG StartPA; UCHAR LegacySupport; BOOLEAN IsChirpHandled; UCHAR Reserved2; @@ -76,7 +76,7 @@ typedef struct _USBPORT_ENDPOINT_PROPERTIES { ULONG TransferType; ULONG Direction; ULONG_PTR BufferVA; - ULONG_PTR BufferPA; + ULONG BufferPA; ULONG BufferLength; ULONG Reserved3; ULONG MaxTransferSize; @@ -454,7 +454,7 @@ typedef ULONG typedef PVOID (NTAPI *PUSBPORT_GET_MAPPED_VIRTUAL_ADDRESS)( - PVOID, + ULONG, PVOID, PVOID);

6 years, 4 months

← Newer
1
...
15
16
17
18
19
20
21
22
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs May 2018