[KMTEST] Handle failure in KmtLoadDriver and KmtOpenDriver

modules/rostests/kmtests/example/Example_user.c

···
     SYSTEM_INFO SystemInfo;
     MY_STRUCT MyStruct[2] = { { 123, ":D" }, { 0 } };
     DWORD Length = sizeof MyStruct;
+    DWORD Error;
 
     trace("Message from user-mode\n");
 
···
     KmtRunKernelTest("Example");
 
     /* now start the special-purpose driver */
-    KmtLoadDriver(L"Example", FALSE);
-    trace("After Entry\n");
-    KmtOpenDriver();
+    Error = KmtLoadAndOpenDriver(L"Example", FALSE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return;
     trace("After Create\n");
 
     ok(KmtSendToDriver(IOCTL_NOTIFY) == ERROR_SUCCESS, "\n");

modules/rostests/kmtests/hidparse/HidP_user.c

···
     KmtStartService(L"hidusb", &ServiceHandle);
     CloseServiceHandle(ServiceHandle);
 
-    KmtLoadDriver(L"HidP", FALSE);
-    KmtOpenDriver();
+    Error = KmtLoadAndOpenDriver(L"HidP", FALSE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return;
 
     Error = KmtSendToDriver(IOCTL_TEST_DESCRIPTION);
     ok(Error == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %lx\n", Error);
 
     KmtCloseDriver();
     KmtUnloadDriver();
-}
+}

modules/rostests/kmtests/include/kmt_test.h

···
 #elif defined KMT_USER_MODE
 DWORD KmtRunKernelTest(IN PCSTR TestName);
 
-VOID KmtLoadDriver(IN PCWSTR ServiceName, IN BOOLEAN RestartIfRunning);
+DWORD KmtLoadDriver(IN PCWSTR ServiceName, IN BOOLEAN RestartIfRunning);
 VOID KmtUnloadDriver(VOID);
-VOID KmtOpenDriver(VOID);
+DWORD KmtOpenDriver(VOID);
 VOID KmtCloseDriver(VOID);
+DWORD KmtLoadAndOpenDriver(IN PCWSTR ServiceName, IN BOOLEAN RestartIfRunning);
 
 DWORD KmtSendToDriver(IN DWORD ControlCode);
 DWORD KmtSendStringToDriver(IN DWORD ControlCode, IN PCSTR String);

modules/rostests/kmtests/kernel32/FileAttributes_user.c

···
     PCWSTR FileName = L"\\\\.\\Global\\GLOBALROOT\\Device\\Kmtest-kernel32\\Somefile";
     BOOL Ret;
     DWORD Attributes;
+    DWORD Error;
 
-    KmtLoadDriver(L"kernel32", FALSE);
-    KmtOpenDriver();
+    Error = KmtLoadAndOpenDriver(L"kernel32", FALSE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return;
 
     /* Set read-only attribute */
     KmtSendUlongToDriver(IOCTL_EXPECT_SET_ATTRIBUTES, FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_NORMAL);

modules/rostests/kmtests/kernel32/FindFile_user.c

···
     const INT TestCount = sizeof(Tests) / sizeof(Tests[0]);
     INT i;
     WCHAR ExpressionBuffer[MAX_PATH];
+    DWORD Error;
 
-    KmtLoadDriver(L"kernel32", FALSE);
-    KmtOpenDriver();
+    Error = KmtLoadAndOpenDriver(L"kernel32", FALSE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return;
 
     for (i = 0; i < TestCount; i++)
     {

modules/rostests/kmtests/kmtest/support.c

···
  * @param RestartIfRunning
  *        TRUE to stop and restart the service if it is already running
  */
-VOID
+DWORD
 KmtLoadDriver(
     IN PCWSTR ServiceName,
     IN BOOLEAN RestartIfRunning)
 {
-    DWORD Error = ERROR_SUCCESS;
     WCHAR ServicePath[MAX_PATH];
 
     StringCbCopyW(ServicePath, sizeof(ServicePath), ServiceName);
···
     StringCbCopyW(TestServiceName, sizeof(TestServiceName), L"Kmtest-");
     StringCbCatW(TestServiceName, sizeof(TestServiceName), ServiceName);
 
-    Error = KmtCreateAndStartService(TestServiceName, ServicePath, NULL, &TestServiceHandle, RestartIfRunning);
-
-    if (Error)
-    {
-        // TODO
-        __debugbreak();
-    }
+    return KmtCreateAndStartService(TestServiceName, ServicePath, NULL, &TestServiceHandle, RestartIfRunning);
 }
 
 /**
···
  *
  * Open special-purpose driver (acquire a device handle)
  */
-VOID
+DWORD
 KmtOpenDriver(VOID)
 {
     DWORD Error = ERROR_SUCCESS;
···
     if (TestDeviceHandle == INVALID_HANDLE_VALUE)
         error(Error);
 
+    return Error;
+}
+
+/**
+ * @name KmtOpenDriver
+ *
+ * Load and open special-purpose driver (acquire a device handle)
+ */
+DWORD
+KmtLoadAndOpenDriver(
+    IN PCWSTR ServiceName,
+    IN BOOLEAN RestartIfRunning)
+{
+    DWORD Error;
+
+    Error = KmtLoadDriver(ServiceName, RestartIfRunning);
     if (Error)
-    {
-        // TODO
-        __debugbreak();
-    }
+        return Error;
+
+    Error = KmtOpenDriver();
+    if (Error)
+        return Error;
 
+    return ERROR_SUCCESS;
 }
 
 /**
···
 
     if (Error)
     {
-        // TODO
-        __debugbreak();
+        DPRINT1("CloseHandle failed: 0x%lx\n", Error);
     }
 }
 

modules/rostests/kmtests/ntos_cc/CcCopyRead_user.c

···
     UNICODE_STRING ReallySmallAlignmentTest = RTL_CONSTANT_STRING(L"\\Device\\Kmtest-CcCopyRead\\ReallySmallAlignmentTest");
     UNICODE_STRING FileBig = RTL_CONSTANT_STRING(L"\\Device\\Kmtest-CcCopyRead\\FileBig");
     UNICODE_STRING BehaviourTestFile = RTL_CONSTANT_STRING(L"\\Device\\Kmtest-CcCopyRead\\BehaviourTestFile");
+    DWORD Error;
 
-    KmtLoadDriver(L"CcCopyRead", FALSE);
-    KmtOpenDriver();
+    Error = KmtLoadAndOpenDriver(L"CcCopyRead", FALSE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return;
 
     InitializeObjectAttributes(&ObjectAttributes, &SmallAlignmentTest, OBJ_CASE_INSENSITIVE, NULL, NULL);
     Status = NtOpenFile(&Handle, FILE_ALL_ACCESS, &ObjectAttributes, &IoStatusBlock, 0, FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);

modules/rostests/kmtests/ntos_cc/CcCopyWrite_user.c

···
     UNICODE_STRING VerySmallFile = RTL_CONSTANT_STRING(L"\\Device\\Kmtest-CcCopyWrite\\VerySmallFile");
     UNICODE_STRING NormalFile = RTL_CONSTANT_STRING(L"\\Device\\Kmtest-CcCopyWrite\\NormalFile");
     UNICODE_STRING BehaviourTestFile = RTL_CONSTANT_STRING(L"\\Device\\Kmtest-CcCopyWrite\\BehaviourTestFile");
+    DWORD Error;
 
-    KmtLoadDriver(L"CcCopyWrite", FALSE);
-    KmtOpenDriver();
+    Error = KmtLoadAndOpenDriver(L"CcCopyWrite", FALSE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return;
 
     InitializeObjectAttributes(&ObjectAttributes, &VerySmallFile, OBJ_CASE_INSENSITIVE, NULL, NULL);
     Status = NtOpenFile(&Handle, FILE_ALL_ACCESS, &ObjectAttributes, &IoStatusBlock, 0, FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);

modules/rostests/kmtests/ntos_cc/CcMapData_user.c

···
     DWORD Ret;
     ULONG TestId;
 
-    KmtLoadDriver(L"CcMapData", FALSE);
-    KmtOpenDriver();
+    Ret = KmtLoadAndOpenDriver(L"CcMapData", FALSE);
+    ok_eq_int(Ret, ERROR_SUCCESS);
+    if (Ret)
+        return;
 
     /* 3 tests for offset
      * 1 test for BCB

modules/rostests/kmtests/ntos_cc/CcPinMappedData_user.c

···
     DWORD Ret;
     ULONG TestId;
 
-    KmtLoadDriver(L"CcPinMappedData", FALSE);
-    KmtOpenDriver();
+    Ret = KmtLoadAndOpenDriver(L"CcPinMappedData", FALSE);
+    ok_eq_int(Ret, ERROR_SUCCESS);
+    if (Ret)
+        return;
 
     /* 1 basic test */
     for (TestId = 0; TestId < 5; ++TestId)

modules/rostests/kmtests/ntos_cc/CcPinRead_user.c

···
     DWORD Ret;
     ULONG TestId;
 
-    KmtLoadDriver(L"CcPinRead", FALSE);
-    KmtOpenDriver();
+    Ret = KmtLoadAndOpenDriver(L"CcPinRead", FALSE);
+    ok_eq_int(Ret, ERROR_SUCCESS);
+    if (Ret)
+        return;
 
     /* 3 tests for offset
      * 1 test for BCB

modules/rostests/kmtests/ntos_cc/CcSetFileSizes_user.c

···
     DWORD Ret;
     ULONG TestId;
 
-    KmtLoadDriver(L"CcSetFileSizes", FALSE);
-    KmtOpenDriver();
+    Ret = KmtLoadAndOpenDriver(L"CcSetFileSizes", FALSE);
+    ok_eq_int(Ret, ERROR_SUCCESS);
+    if (Ret)
+        return;
 
     /* 0: mapped data - only FS
      * 1: copy read - only FS

modules/rostests/kmtests/ntos_io/IoCreateFile_user.c

···
 
     KmtRunKernelTest("IoCreateFile");
 
-    KmtLoadDriver(L"IoCreateFile", FALSE);
-    KmtOpenDriver();
+    Error = KmtLoadAndOpenDriver(L"IoCreateFile", FALSE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return;
 
     Error = KmtSendStringToDriver(IOCTL_CALL_CREATE, NonSymlinkedFileName);
     ok(Error == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %lx\n", Error);

modules/rostests/kmtests/ntos_io/IoDeviceObject_user.c

···
 
 START_TEST(IoDeviceObject)
 {
+    DWORD Error;
+
     /* make sure IoHelper has an existing service key, but is not started */
-    KmtLoadDriver(L"IoHelper", FALSE);
+    Error = KmtLoadDriver(L"IoHelper", FALSE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return;
     KmtUnloadDriver();
 
-    KmtLoadDriver(L"IoDeviceObject", TRUE);
-    KmtOpenDriver();
+    Error = KmtLoadAndOpenDriver(L"IoDeviceObject", TRUE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return;
+
     KmtCloseDriver();
     KmtUnloadDriver();
 }

modules/rostests/kmtests/ntos_io/IoReadWrite_user.c

···
     OBJECT_ATTRIBUTES ObjectAttributes;
     IO_STATUS_BLOCK IoStatus;
     NTSTATUS Status;
+    DWORD Error;
 
-    KmtLoadDriver(L"IoReadWrite", FALSE);
-    KmtOpenDriver();
+    Error = KmtLoadAndOpenDriver(L"IoReadWrite", FALSE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return;
 
     RtlFillMemory(&IoStatus, sizeof(IoStatus), 0x55);
     InitializeObjectAttributes(&ObjectAttributes,

modules/rostests/kmtests/ntos_mm/MmMapLockedPagesSpecifyCache_user.c

···
     SYSTEM_BASIC_INFORMATION BasicInfo;
     NTSTATUS Status;
     ULONG_PTR HighestAddress;
+    DWORD Error;
 
-    KmtLoadDriver(L"MmMapLockedPagesSpecifyCache", FALSE);
-    KmtOpenDriver();
+    Error = KmtLoadAndOpenDriver(L"MmMapLockedPagesSpecifyCache", FALSE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return;
 
     // Less than a page
     SET_BUFFER_LENGTH(BufferLength, 2048);

modules/rostests/kmtests/ntos_mm/NtCreateSection_user.c

···
     UNICODE_STRING InitOnCreate = RTL_CONSTANT_STRING(L"\\Device\\Kmtest-NtCreateSection\\InitOnCreate");
     UNICODE_STRING InitOnRW = RTL_CONSTANT_STRING(L"\\Device\\Kmtest-NtCreateSection\\InitOnRW");
     UNICODE_STRING InvalidInit = RTL_CONSTANT_STRING(L"\\Device\\Kmtest-NtCreateSection\\InvalidInit");
+    DWORD Error;
 
-    KmtLoadDriver(L"NtCreateSection", FALSE);
-    KmtOpenDriver();
+    Error = KmtLoadAndOpenDriver(L"NtCreateSection", FALSE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return;
 
     /* Test 0 */
     InitializeObjectAttributes(&ObjectAttributes, &InvalidInit, OBJ_CASE_INSENSITIVE, NULL, NULL);

modules/rostests/kmtests/ntos_po/PoIrp_user.c

···
 
 START_TEST(PoIrp)
 {
+    DWORD Error;
+
 #if defined(_M_AMD64)
     if (TRUE)
     {
···
     }
 #endif
 
-    KmtLoadDriver(L"PoIrp", TRUE);
-    KmtOpenDriver();
+    Error = KmtLoadAndOpenDriver(L"PoIrp", TRUE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return;
+
     KmtSendToDriver(IOCTL_RUN_TEST);
     KmtCloseDriver();
     KmtUnloadDriver();

modules/rostests/kmtests/tcpip/TcpIp_user.c

···
 #include "tcpip.h"
 
 static
-void
+DWORD
 LoadTcpIpTestDriver(void)
 {
+    DWORD Error;
+
     /* Start the special-purpose driver */
-    KmtLoadDriver(L"TcpIp", FALSE);
-    KmtOpenDriver();
+    Error = KmtLoadAndOpenDriver(L"TcpIp", FALSE);
+    ok_eq_int(Error, ERROR_SUCCESS);
+    if (Error)
+        return Error;
+
+    return ERROR_SUCCESS;
 }
 
 static
···
 {
     DWORD Error;
 
-    LoadTcpIpTestDriver();
+    Error = LoadTcpIpTestDriver();
+    ok_eq_int(Error, 0);
+    if (Error)
+        return;
 
     Error = KmtSendToDriver(IOCTL_TEST_TDI);
     ok_eq_ulong(Error, ERROR_SUCCESS);