cleanup debug prints

jxy-s · Sep 19, 2024 · 9931511 · 9931511
1 parent 72858c2
commit 9931511
Show file tree

Hide file tree

Showing 8 changed files with 126 additions and 158 deletions.
diff --git a/vfdynf/delayld.c b/vfdynf/delayld.c
@@ -90,11 +90,11 @@ BOOLEAN NTAPI AVrfpDelayLoad(
         status = LdrLoadDll(NULL, NULL, &dllEntry->DllName, &baseAddress);
         if (!NT_SUCCESS(status))
         {
-            DbgPrintEx(DPFLTR_VERIFIER_ID,
-                       DPFLTR_ERROR_LEVEL,
-                       "AVRF: failed to delay load %wZ (0x%08x)\n",
-                       &dllEntry->DllName,
-                       status);
+            AVrfDbgPrint(DPFLTR_ERROR_LEVEL,
+                         "failed to delay load %wZ (0x%08x)",
+                         &dllEntry->DllName,
+                         status);
+
             goto Exit;
         }
 
@@ -110,12 +110,12 @@ BOOLEAN NTAPI AVrfpDelayLoad(
                                             entry->Store);
             if (!NT_SUCCESS(status))
             {
-                DbgPrintEx(DPFLTR_VERIFIER_ID,
-                           DPFLTR_ERROR_LEVEL,
-                           "AVRF: failed to delay load %wZ!%wZ (0x%08x)\n",
-                           &dllEntry->DllName,
-                           &entry->ProcedureName,
-                           status);
+                AVrfDbgPrint(DPFLTR_ERROR_LEVEL,
+                             "failed to delay load %wZ!%hZ (0x%08x)",
+                             &dllEntry->DllName,
+                             &entry->ProcedureName,
+                             status);
+
                 __debugbreak();
                 goto Exit;
             }

diff --git a/vfdynf/dllmain.c b/vfdynf/dllmain.c
@@ -625,9 +625,8 @@ VOID AVrfpRefreshLoadedModuleList(
         module = RtlAllocateHeap(RtlProcessHeap(), 0, size);
         if (!module)
         {
-            DbgPrintEx(DPFLTR_VERIFIER_ID,
-                       DPFLTR_ERROR_LEVEL,
-                       "AVRF: failed to allocate module entry\n");
+            AVrfDbgPuts(DPFLTR_ERROR_LEVEL, "failed to allocate module entry");
+
             __debugbreak();
             continue;
         }
@@ -852,9 +851,9 @@ BOOLEAN AVrfpProviderProcessVerifier(
     desc = (PRTL_VERIFIER_PROVIDER_DESCRIPTOR*)Reserved;
     if (!desc)
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: expected descriptor output parameter is null");
+        AVrfDbgPuts(DPFLTR_ERROR_LEVEL,
+                    "expected descriptor output parameter is null");
+
         return FALSE;
     }
 
@@ -863,10 +862,10 @@ BOOLEAN AVrfpProviderProcessVerifier(
     status = VerifierRegisterProvider(Module, &AVrfpProviderDescriptor);
     if (!NT_SUCCESS(status))
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: provider registration failed (0x%08x)",
-                   status);
+        AVrfDbgPrint(DPFLTR_ERROR_LEVEL,
+                     "provider registration failed (0x%08x)",
+                     status);
+
         return FALSE;
     }
 
@@ -885,10 +884,10 @@ BOOLEAN AVrfpProviderProcessAttach(
                                   0);
     if (err != ERROR_SUCCESS)
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: layer registration failed (%lu)",
-                   err);
+        AVrfDbgPrint(DPFLTR_ERROR_LEVEL,
+                     "layer registration failed (%lu)",
+                     err);
+
         return FALSE;
     }
 
@@ -906,54 +905,48 @@ BOOLEAN AVrfpProviderProcessAttach(
 
     if (!AVrfLinkHooks())
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: failed to link hooks");
+        AVrfDbgPuts(DPFLTR_ERROR_LEVEL, "failed to link hooks");
+
         __debugbreak();
         return FALSE;
     }
 
     if (!AVrfSymProcessAttach())
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: failed to setup symbol provider");
+        AVrfDbgPuts(DPFLTR_ERROR_LEVEL, "failed to setup symbol provider");
+
         __debugbreak();
         return FALSE;
     }
 
     if (!AVrfStopProcessAttach())
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: failed to setup stop handling");
+        AVrfDbgPuts(DPFLTR_ERROR_LEVEL, "failed to setup stop handling");
+
         __debugbreak();
         return FALSE;
     }
 
     if (!AVrfFuzzProcessAttach())
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: failed to setup fuzzing");
+        AVrfDbgPuts(DPFLTR_ERROR_LEVEL, "failed to setup fuzzing");
+
         __debugbreak();
         return FALSE;
     }
 
     if (!AVrfExceptProcessAttach())
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: failed to set exception handler");
+        AVrfDbgPuts(DPFLTR_ERROR_LEVEL, "failed to set exception handler");
+
         __debugbreak();
         return FALSE;
     }
 
     if (!AVrfFaultProcessAttach())
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: failed to setup fault injection");
+        AVrfDbgPuts(DPFLTR_ERROR_LEVEL, "failed to setup fault injection");
+
         __debugbreak();
         return FALSE;
     }

diff --git a/vfdynf/except.c b/vfdynf/except.c
@@ -73,9 +73,8 @@ VOID AVrfGuardToConvertToInPageError(
     }
     else
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: out of guard page slots!");
+        AVrfDbgPuts(DPFLTR_ERROR_LEVEL, "out of guard page slots");
+
         __debugbreak();
     }
 

diff --git a/vfdynf/fault.c b/vfdynf/fault.c
@@ -113,9 +113,8 @@ BOOLEAN AVrfpInitExclusionsRegexInternal(
                                        count * sizeof(PCRE2_HANDLE));
     if (!Exclusion->Regex)
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: failed to allocate exclusion regex!\n");
+        AVrfDbgPuts(DPFLTR_ERROR_LEVEL, "failed to allocate exclusion regex");
+
         __debugbreak();
         return FALSE;
     }
@@ -137,10 +136,10 @@ BOOLEAN AVrfpInitExclusionsRegexInternal(
         status = Pcre2Compile(&regex, &pattern);
         if (!NT_SUCCESS(status))
         {
-            DbgPrintEx(DPFLTR_VERIFIER_ID,
-                       DPFLTR_ERROR_LEVEL,
-                       "AVRF: failed processing regex! (0x%08x)\n",
-                       status);
+            AVrfDbgPrint(DPFLTR_ERROR_LEVEL,
+                         "regex failed to compile (0x%08x)",
+                         status);
+
             __debugbreak();
             return FALSE;
         }
@@ -198,10 +197,10 @@ BOOLEAN AVrfpInitIncludeRegex(
         status = Pcre2Compile(&AVrfpFaultContext.IncludeRegex, &pattern);
         if (!NT_SUCCESS(status))
         {
-            DbgPrintEx(DPFLTR_VERIFIER_ID,
-                       DPFLTR_ERROR_LEVEL,
-                       "AVRF: failed processing regex! (0x%08x)\n",
-                       status);
+            AVrfDbgPrint(DPFLTR_ERROR_LEVEL,
+                         "regex failed to compile (0x%08x)",
+                         status);
+
             __debugbreak();
             return FALSE;
         }
@@ -219,10 +218,10 @@ BOOLEAN AVrfpInitIncludeRegex(
         status = Pcre2Compile(&AVrfpFaultContext.TypeIncludeRegex[i], &pattern);
         if (!NT_SUCCESS(status))
         {
-            DbgPrintEx(DPFLTR_VERIFIER_ID,
-                       DPFLTR_ERROR_LEVEL,
-                       "AVRF: failed processing regex! (0x%08x)\n",
-                       status);
+            AVrfDbgPrint(DPFLTR_ERROR_LEVEL,
+                         "regex failed to compile (0x%08x)",
+                         status);
+
             __debugbreak();
             return FALSE;
         }
@@ -340,19 +339,11 @@ BOOLEAN AVrfIsCallerIncluded(
 
     if (!AVrfpFaultContext.Initialized)
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_WARNING_LEVEL,
-                   "AVRF: fault injection not yet initialized\n");
-
         return FALSE;
     }
 
     if (!CallerAddress)
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_WARNING_LEVEL,
-                   "AVRF: caller address is null\n");
-
         return FALSE;
     }
 
@@ -486,9 +477,7 @@ VOID AVrfpCacheFaultInjectResult(
                                           StackHash);
         if (!stackEntry)
         {
-            DbgPrintEx(DPFLTR_VERIFIER_ID,
-                       DPFLTR_ERROR_LEVEL,
-                       "AVRF: failed to insert new stack entry!\n");
+            AVrfDbgPuts(DPFLTR_ERROR_LEVEL, "failed to insert new stack entry");
 
             goto Exit;
         }
@@ -526,19 +515,11 @@ BOOLEAN AVrfShouldFaultInject(
 
     if (!AVrfpFaultContext.Initialized)
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_WARNING_LEVEL,
-                   "AVRF: fault injection not yet initialized\n");
-
         goto Exit;
     }
 
     if (!CallerAddress)
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_WARNING_LEVEL,
-                   "AVRF: caller address is null\n");
-
         goto Exit;
     }
 
@@ -609,10 +590,9 @@ BOOLEAN AVrfShouldFaultInject(
                                &AVrfpFaultContext.SymTimeout);
     if (status != STATUS_SUCCESS)
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: AVrfSymGetSymbol failed (0x%08x)\n",
-                   status);
+        AVrfDbgPrint(DPFLTR_ERROR_LEVEL,
+                     "AVrfSymGetSymbol failed (0x%08x)",
+                     status);
 
         goto Exit;
     }
@@ -677,9 +657,9 @@ BOOLEAN AVrfFaultProcessAttach(
 
     if (!AVrfpInitRegex())
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: failed to initialized exclusions regex!\n");
+        AVrfDbgPuts(DPFLTR_ERROR_LEVEL,
+                    "failed to initialize exclusions regex");
+
         __debugbreak();
         return FALSE;
     }
@@ -688,10 +668,10 @@ BOOLEAN AVrfFaultProcessAttach(
                                               &AVrfpFaultContext.TypeBase);
     if (err != ERROR_SUCCESS)
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: failed to register fault injection provider (%lu)\n",
-                   err);
+        AVrfDbgPrint(DPFLTR_ERROR_LEVEL,
+                     "failed to register fault injection provider (%lu)",
+                     err);
+
         return FALSE;
     }
 
@@ -757,10 +737,9 @@ BOOLEAN AVrfFaultProcessAttach(
         seed = HandleToULong(NtCurrentThreadId()) ^ NtGetTickCount();
         rand = RtlRandomEx(&seed);
 
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_INFO_LEVEL,
-                   "AVRF: generated and using random fault injection seed %lu\n",
-                   rand);
+        AVrfDbgPrint(DPFLTR_INFO_LEVEL,
+                     "generated and using random fault injection seed %lu",
+                     rand);
 
         VerifierSetFaultInjectionSeed(rand);
     }
@@ -771,9 +750,7 @@ BOOLEAN AVrfFaultProcessAttach(
 
     AVrfInitializeCriticalSection(&AVrfpFaultContext.CriticalSection);
 
-    DbgPrintEx(DPFLTR_VERIFIER_ID,
-               DPFLTR_INFO_LEVEL,
-               "AVRF: dynamic fault injection initialized\n");
+    AVrfDbgPuts(DPFLTR_INFO_LEVEL, "dynamic fault injection initialized");
 
     AVrfpFaultContext.Initialized = TRUE;
     return TRUE;

diff --git a/vfdynf/fuzz.c b/vfdynf/fuzz.c
@@ -133,10 +133,10 @@ BOOLEAN NTAPI AVrfpFuzzRunOnceRoutine(
 
     if (!NT_SUCCESS(status))
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: failed to initialize fuzz vector (0x%08x)\n",
-                   status);
+        AVrfDbgPrint(DPFLTR_ERROR_LEVEL,
+                     "failed to initialize fuzz vector (0x%08x)",
+                     status);
+
         __debugbreak();
         return FALSE;
     }
@@ -607,9 +607,7 @@ PVOID AVrfFuzzMemoryMapping(
     }
     else
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: out of fuzzing mmap slots!");
+        AVrfDbgPuts(DPFLTR_ERROR_LEVEL, "out of fuzzing mmap slots");
         __debugbreak();
 
         RtlFreeHeap(RtlProcessHeap(), 0, baseAddress);

diff --git a/vfdynf/stop.c b/vfdynf/stop.c
@@ -78,10 +78,10 @@ BOOLEAN AVrfStopProcessAttach(
     status = Pcre2Compile(&AVrfpStopRegex, &pattern);
     if (!NT_SUCCESS(status))
     {
-        DbgPrintEx(DPFLTR_VERIFIER_ID,
-                   DPFLTR_ERROR_LEVEL,
-                   "AVRF: failed processing regex! (0x%08x)\n",
-                   status);
+        AVrfDbgPrint(DPFLTR_ERROR_LEVEL,
+                     "regex failed to compile (0x%08x)",
+                     status);
+
         __debugbreak();
         return FALSE;
     }