[idd] install: quiesce devices during driver updates

Stop LGIddHelper before updating either UMDF stack. Disable LGInput
before LGIdd, update both packages while quiesced, then restore the
provider before its dependent and start the service last.

Use in-use replacement for UMDF binaries and prevent the INF from
restarting the Helper during package installation. Report each
SetupAPI restart result and propagate it through NSIS.

Roll back transaction-owned devices, packages, and service state on
fresh-install failure. Preserve dependency order during removal and
select the package actually installed on each devnode.

idd/LGIddInstall/LGIddInstall.c

@@ -27,6 +27,7 @@
 #include <stdbool.h>
 #include <string.h>
 #include <windows.h>
+#include <cfgmgr32.h>
 #include <devguid.h>
 #include <setupapi.h>
 #include <shlwapi.h>
@@ -34,6 +35,8 @@
 #include <sddl.h>
 #include <aclapi.h>
 
+#pragma comment(lib, "cfgmgr32.lib")
+
 #define LGIDD_CLASS_GUID GUID_DEVCLASS_DISPLAY
 #define LGIDD_CLASS_NAME L"Display"
 #define LGIDD_NAME L"LGIdd"
@@ -49,7 +52,12 @@
 #define LGINPUT_INF_NAME L"LGInput.inf"
 #define LGINPUT_PACKAGE_DIR L"LGInput"
 #define LGIDD_REGKEY L"Software\\LookingGlass\\IDD"
+#define LGIDD_HELPER_SERVICE L"LGIddHelper"
 #define DEVICE_COUNT 2
+#define STATE_WAIT_TIMEOUT_MS 30000
+#define EXIT_RESTART_REQUIRED 12
+// The operation failed, but a partial change or rollback still needs reboot.
+#define EXIT_FAILURE_RESTART_REQUIRED 13
 
 typedef struct DeviceDesc
 {
@@ -131,6 +139,206 @@ void debugWinError(const wchar_t *desc, HRESULT status)
   LocalFree(buffer);
 }
 
+void debugConfigError(const wchar_t *desc, CONFIGRET status)
+{
+  debugWinError(desc, CM_MapCrToWin32Err(status, ERROR_GEN_FAILURE));
+}
+
+bool queryServiceStatus(
+  SC_HANDLE service,
+  SERVICE_STATUS_PROCESS *status)
+{
+  DWORD bytes;
+  if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO,
+      (LPBYTE) status, sizeof(*status), &bytes))
+  {
+    debugWinError(L"QueryServiceStatusEx", GetLastError());
+    return false;
+  }
+  return true;
+}
+
+bool waitForServiceState(SC_HANDLE service, DWORD desiredState)
+{
+  const ULONGLONG deadline = GetTickCount64() + STATE_WAIT_TIMEOUT_MS;
+  for (;;)
+  {
+    SERVICE_STATUS_PROCESS status;
+    if (!queryServiceStatus(service, &status))
+      return false;
+    if (status.dwCurrentState == desiredState)
+      return true;
+
+    if (GetTickCount64() >= deadline)
+    {
+      debugWinError(L"Timed out waiting for LGIddHelper", ERROR_TIMEOUT);
+      return false;
+    }
+
+    DWORD delay = status.dwWaitHint / 10;
+    if (delay < 100)
+      delay = 100;
+    else if (delay > 1000)
+      delay = 1000;
+    Sleep(delay);
+  }
+}
+
+bool stopHelperService(bool *existed, bool *wasRunning)
+{
+  if (existed)
+    *existed = false;
+  *wasRunning = false;
+
+  SC_HANDLE manager = OpenSCManagerW(
+    NULL, NULL, SC_MANAGER_CONNECT);
+  if (!manager)
+  {
+    debugWinError(L"OpenSCManagerW", GetLastError());
+    return false;
+  }
+
+  SC_HANDLE service = OpenServiceW(manager, LGIDD_HELPER_SERVICE,
+    SERVICE_QUERY_STATUS | SERVICE_STOP);
+  if (!service)
+  {
+    const DWORD error = GetLastError();
+    CloseServiceHandle(manager);
+    if (error == ERROR_SERVICE_DOES_NOT_EXIST)
+      return true;
+    debugWinError(L"OpenServiceW(LGIddHelper)", error);
+    return false;
+  }
+  if (existed)
+    *existed = true;
+
+  SERVICE_STATUS_PROCESS status;
+  bool result = queryServiceStatus(service, &status);
+  if (result && status.dwCurrentState != SERVICE_STOPPED)
+  {
+    *wasRunning = status.dwCurrentState != SERVICE_STOP_PENDING;
+    if (status.dwCurrentState == SERVICE_START_PENDING)
+      result = waitForServiceState(service, SERVICE_RUNNING);
+
+    if (result && status.dwCurrentState != SERVICE_STOP_PENDING)
+    {
+      SERVICE_STATUS controlStatus;
+      if (!ControlService(service, SERVICE_CONTROL_STOP, &controlStatus))
+      {
+        const DWORD error = GetLastError();
+        if (error != ERROR_SERVICE_NOT_ACTIVE)
+        {
+          debugWinError(L"ControlService(LGIddHelper, STOP)", error);
+          result = false;
+        }
+      }
+    }
+
+    if (result)
+      result = waitForServiceState(service, SERVICE_STOPPED);
+  }
+
+  CloseServiceHandle(service);
+  CloseServiceHandle(manager);
+  return result;
+}
+
+bool deleteHelperService()
+{
+  SC_HANDLE manager = OpenSCManagerW(
+    NULL, NULL, SC_MANAGER_CONNECT);
+  if (!manager)
+  {
+    debugWinError(L"OpenSCManagerW", GetLastError());
+    return false;
+  }
+
+  SC_HANDLE service = OpenServiceW(manager, LGIDD_HELPER_SERVICE,
+    DELETE);
+  if (!service)
+  {
+    const DWORD error = GetLastError();
+    CloseServiceHandle(manager);
+    if (error == ERROR_SERVICE_DOES_NOT_EXIST)
+      return true;
+    debugWinError(L"OpenServiceW(LGIddHelper, DELETE)", error);
+    return false;
+  }
+
+  bool result = true;
+  if (!DeleteService(service))
+  {
+    const DWORD error = GetLastError();
+    if (error != ERROR_SERVICE_MARKED_FOR_DELETE)
+    {
+      debugWinError(L"DeleteService(LGIddHelper)", error);
+      result = false;
+    }
+  }
+
+  CloseServiceHandle(service);
+  CloseServiceHandle(manager);
+  return result;
+}
+
+bool startHelperService()
+{
+  SC_HANDLE manager = OpenSCManagerW(
+    NULL, NULL, SC_MANAGER_CONNECT);
+  if (!manager)
+  {
+    debugWinError(L"OpenSCManagerW", GetLastError());
+    return false;
+  }
+
+  SC_HANDLE service = OpenServiceW(manager, LGIDD_HELPER_SERVICE,
+    SERVICE_QUERY_STATUS | SERVICE_START);
+  if (!service)
+  {
+    const DWORD error = GetLastError();
+    CloseServiceHandle(manager);
+    debugWinError(L"OpenServiceW(LGIddHelper)", error);
+    return false;
+  }
+
+  bool result = true;
+  SERVICE_STATUS_PROCESS status;
+  if (!queryServiceStatus(service, &status))
+    result = false;
+  else if (status.dwCurrentState != SERVICE_RUNNING)
+  {
+    if (status.dwCurrentState == SERVICE_STOP_PENDING)
+      result = waitForServiceState(service, SERVICE_STOPPED);
+
+    if (result && status.dwCurrentState != SERVICE_START_PENDING &&
+        !StartServiceW(service, 0, NULL))
+    {
+      const DWORD error = GetLastError();
+      if (error != ERROR_SERVICE_ALREADY_RUNNING)
+      {
+        debugWinError(L"StartServiceW(LGIddHelper)", error);
+        result = false;
+      }
+    }
+
+    if (result)
+      result = waitForServiceState(service, SERVICE_RUNNING);
+  }
+
+  CloseServiceHandle(service);
+  CloseServiceHandle(manager);
+  return result;
+}
+
+void logRestart(
+  const DeviceDesc *device,
+  const wchar_t *operation,
+  BOOL needRestart)
+{
+  wprintf(L"%s: %s completed; restart required: %s\n",
+    device->name, operation, needRestart ? L"yes" : L"no");
+}
+
 bool ensureKeyWithAce()
 {
   bool result = false;
@@ -253,8 +461,10 @@ typedef bool (*DEVICE_FOUND_PROC)(HDEVINFO hDevInfo, PSP_DEVINFO_DATA pDevInfo,
 
 typedef struct DeviceRemovalContext
 {
+  const DeviceDesc *device;
   LPBOOL pbNeedRestart;
   bool success;
+  bool deviceRemoved;
 }
 DeviceRemovalContext;
 
@@ -328,29 +538,190 @@ fail:
   return false;
 }
 
-enum DeviceCreated {
+typedef struct DeviceRuntimeState
-  DEVICE_CREATED,
-  DEVICE_NOT_CREATED,
-  DEVICE_UNKNOWN,
-};
-
-bool isDeviceCreatedEnum(HDEVINFO hDevInfo, PSP_DEVINFO_DATA pDevInfo, void *pContext)
 {
-  enum DeviceCreated *result = pContext;
+  const DeviceDesc *device;
-  *result = DEVICE_CREATED;
+  bool success;
+  bool present;
+  bool started;
+  bool usable;
+  bool disabled;
+  bool created;
+  bool rollbackDeviceSafe;
+  WCHAR instanceId[MAX_DEVICE_ID_LEN];
+  WCHAR stagedInfPath[MAX_PATH];
+}
+DeviceRuntimeState;
+
+bool captureDeviceStateEnum(
+  HDEVINFO hDevInfo,
+  PSP_DEVINFO_DATA pDevInfo,
+  void *pContext)
+{
+  DeviceRuntimeState *state = pContext;
+  if (!SetupDiGetDeviceInstanceIdW(hDevInfo, pDevInfo,
+      state->instanceId, ARRAYSIZE(state->instanceId), NULL))
+  {
+    debugWinError(L"SetupDiGetDeviceInstanceIdW", GetLastError());
+    state->success = false;
     return false;
   }
 
-enum DeviceCreated isDeviceCreated(const DeviceDesc *device)
+  ULONG status;
+  ULONG problem;
+  const CONFIGRET cr = CM_Get_DevNode_Status(
+    &status, &problem, pDevInfo->DevInst, 0);
+  if (cr != CR_SUCCESS)
   {
-  enum DeviceCreated result = DEVICE_UNKNOWN;
+    debugConfigError(L"CM_Get_DevNode_Status", cr);
-  if (findDevice(device, isDeviceCreatedEnum, &result) && result == DEVICE_UNKNOWN)
+    state->success = false;
-    result = DEVICE_NOT_CREATED;
+    return false;
-  return result;
   }
 
-bool createDevice(const DeviceDesc *device)
+  state->present = true;
+  state->started = (status & DN_STARTED) != 0;
+  state->usable  = state->started &&
+    !(status & (DN_HAS_PROBLEM | DN_WILL_BE_REMOVED));
+  return false;
+}
+
+bool captureDeviceState(
+  const DeviceDesc *device,
+  DeviceRuntimeState *state)
 {
+  ZeroMemory(state, sizeof(*state));
+  state->device  = device;
+  state->success = true;
+  return findDevice(device, captureDeviceStateEnum, state) &&
+    state->success;
+}
+
+bool deviceIsUsable(const DeviceDesc *device)
+{
+  DeviceRuntimeState state;
+  return captureDeviceState(device, &state) &&
+    state.present && state.usable;
+}
+
+bool waitForDeviceState(
+  const DeviceRuntimeState *state,
+  bool started)
+{
+  const ULONGLONG deadline = GetTickCount64() + STATE_WAIT_TIMEOUT_MS;
+  for (;;)
+  {
+    DEVINST devInst;
+    CONFIGRET cr = CM_Locate_DevNodeW(
+      &devInst, (DEVINSTID_W) state->instanceId, CM_LOCATE_DEVNODE_NORMAL);
+    if (cr != CR_SUCCESS)
+    {
+      debugConfigError(L"CM_Locate_DevNodeW", cr);
+      return false;
+    }
+
+    ULONG status;
+    ULONG problem;
+    cr = CM_Get_DevNode_Status(&status, &problem, devInst, 0);
+    if (cr != CR_SUCCESS)
+    {
+      debugConfigError(L"CM_Get_DevNode_Status", cr);
+      return false;
+    }
+    if (((status & DN_STARTED) != 0) == started)
+      return true;
+
+    if (GetTickCount64() >= deadline)
+    {
+      fwprintf(stderr, L"%s: timed out waiting for device to %s\n",
+        state->device->name, started ? L"start" : L"stop");
+      return false;
+    }
+    Sleep(100);
+  }
+}
+
+bool disableDevice(DeviceRuntimeState *state)
+{
+  if (!state->present || !state->started)
+    return true;
+
+  DEVINST devInst;
+  CONFIGRET cr = CM_Locate_DevNodeW(
+    &devInst, state->instanceId, CM_LOCATE_DEVNODE_NORMAL);
+  if (cr != CR_SUCCESS)
+  {
+    debugConfigError(L"CM_Locate_DevNodeW", cr);
+    return false;
+  }
+
+  wprintf(L"Temporarily disabling %s...\n", state->device->name);
+  cr = CM_Disable_DevNode(devInst, CM_DISABLE_UI_NOT_OK);
+  if (cr != CR_SUCCESS)
+  {
+    debugConfigError(L"CM_Disable_DevNode", cr);
+    return false;
+  }
+
+  state->disabled = true;
+  return waitForDeviceState(state, false);
+}
+
+bool enableDevice(DeviceRuntimeState *state)
+{
+  if (!state->disabled)
+    return true;
+
+  DEVINST devInst;
+  CONFIGRET cr = CM_Locate_DevNodeW(
+    &devInst, state->instanceId, CM_LOCATE_DEVNODE_NORMAL);
+  if (cr != CR_SUCCESS)
+  {
+    debugConfigError(L"CM_Locate_DevNodeW", cr);
+    return false;
+  }
+
+  wprintf(L"Re-enabling %s...\n", state->device->name);
+  cr = CM_Enable_DevNode(devInst, 0);
+  if (cr != CR_SUCCESS)
+  {
+    debugConfigError(L"CM_Enable_DevNode", cr);
+    return false;
+  }
+
+  if (!waitForDeviceState(state, true))
+    return false;
+  state->disabled = false;
+  return true;
+}
+
+bool enableDevices(
+  DeviceRuntimeState *idd,
+  DeviceRuntimeState *input)
+{
+  if (!enableDevice(idd))
+    return false;
+
+  if (input->disabled && !deviceIsUsable(&LGIDD_DEVICE))
+  {
+    fwprintf(stderr,
+      L"LGInput remains disabled because LGIdd is not usable\n");
+    return false;
+  }
+
+  return enableDevice(input);
+}
+
+DeviceRuntimeState *runtimeStateForDevice(
+  const DeviceDesc *device,
+  DeviceRuntimeState *idd,
+  DeviceRuntimeState *input)
+{
+  return device == &LGIDD_DEVICE ? idd : input;
+}
+
+bool createDevice(DeviceRuntimeState *state)
+{
+  const DeviceDesc *device = state->device;
   HDEVINFO hDevInfo = SetupDiCreateDeviceInfoList(device->classGuid, NULL);
   if (hDevInfo == INVALID_HANDLE_VALUE)
   {
@@ -372,12 +743,20 @@ bool createDevice(const DeviceDesc *device)
     goto fail;
   }
 
+  if (!SetupDiGetDeviceInstanceIdW(hDevInfo, &devInfo,
+      state->instanceId, ARRAYSIZE(state->instanceId), NULL))
+  {
+    debugWinError(L"SetupDiGetDeviceInstanceIdW", GetLastError());
+    goto fail;
+  }
+
   if (!SetupDiCallClassInstaller(DIF_REGISTERDEVICE, hDevInfo, &devInfo))
   {
     debugWinError(L"SetupDiCallClassInstaller", GetLastError());
     goto fail;
   }
 
+  SetupDiDestroyDeviceInfoList(hDevInfo);
   return true;
 
 fail:
@@ -388,34 +767,69 @@ fail:
 bool destroyDeviceEnum(HDEVINFO hDevInfo, PSP_DEVINFO_DATA pDevInfo, void *pContext)
 {
   DeviceRemovalContext *context = pContext;
-  BOOL bNeedRestart;
+  BOOL bNeedRestart = FALSE;
   WCHAR szInfPath[MAX_PATH] = { 0 };
 
+  SP_DEVINSTALL_PARAMS_W installParams =
+    { .cbSize = sizeof installParams };
+  if (!SetupDiGetDeviceInstallParamsW(hDevInfo, pDevInfo,
+      &installParams))
+  {
+    debugWinError(L"SetupDiGetDeviceInstallParamsW", GetLastError());
+    context->success = false;
+    goto uninstall;
+  }
+
+  installParams.FlagsEx |= DI_FLAGSEX_INSTALLEDDRIVER;
+  if (!SetupDiSetDeviceInstallParamsW(hDevInfo, pDevInfo,
+      &installParams))
+  {
+    debugWinError(L"SetupDiSetDeviceInstallParamsW", GetLastError());
+    context->success = false;
+    goto uninstall;
+  }
+
   if (!SetupDiBuildDriverInfoList(hDevInfo, pDevInfo, SPDIT_COMPATDRIVER))
   {
     debugWinError(L"SetupDiBuildDriverInfoList", GetLastError());
+    context->success = false;
     goto uninstall;
   }
 
   SP_DRVINFO_DATA_W drvInfo = { .cbSize = sizeof drvInfo };
-  if (!SetupDiEnumDriverInfoW(hDevInfo, pDevInfo, SPDIT_COMPATDRIVER, 0, &drvInfo))
+  if (!SetupDiEnumDriverInfoW(hDevInfo, pDevInfo,
+      SPDIT_COMPATDRIVER, 0, &drvInfo))
   {
-    debugWinError(L"SetupDiEnumDriverInfoW", GetLastError());
+    const DWORD error = GetLastError();
+    if (error == ERROR_NO_MORE_ITEMS)
+      goto uninstall;
+    debugWinError(L"SetupDiEnumDriverInfoW", error);
+    context->success = false;
     goto uninstall;
   }
 
-  SP_DRVINFO_DETAIL_DATA_W drvInfoDetail = { .cbSize = sizeof drvInfoDetail };
+  SP_DRVINFO_DETAIL_DATA_W drvInfoDetail =
-  SetupDiGetDriverInfoDetailW(hDevInfo, pDevInfo, &drvInfo, &drvInfoDetail, sizeof drvInfoDetail, NULL);
+    { .cbSize = sizeof drvInfoDetail };
-
+  if (SetupDiGetDriverInfoDetailW(hDevInfo, pDevInfo, &drvInfo,
-  DWORD dwLastError = GetLastError();
+      &drvInfoDetail, sizeof drvInfoDetail, NULL) ||
-  if (dwLastError == ERROR_INSUFFICIENT_BUFFER)
+      GetLastError() == ERROR_INSUFFICIENT_BUFFER)
-    wcscpy_s(szInfPath, MAX_PATH, drvInfoDetail.InfFileName);
+  {
+    wcscpy_s(szInfPath, ARRAYSIZE(szInfPath),
+      drvInfoDetail.InfFileName);
+  }
   else
-    debugWinError(L"SetupDiEnumDriverInfoW", GetLastError());
+  {
+    debugWinError(L"SetupDiGetDriverInfoDetailW", GetLastError());
+    context->success = false;
+  }
 
 uninstall:
   if (DiUninstallDevice(NULL, hDevInfo, pDevInfo, 0, &bNeedRestart))
+  {
+    logRestart(context->device, L"DiUninstallDevice", bNeedRestart);
     *context->pbNeedRestart |= bNeedRestart;
+    context->deviceRemoved = true;
+  }
   else
   {
     debugWinError(L"DiUninstallDevice", GetLastError());
@@ -425,8 +839,12 @@ uninstall:
 
   if (*szInfPath)
   {
+    bNeedRestart = FALSE;
     if (DiUninstallDriverW(NULL, szInfPath, 0, &bNeedRestart))
+    {
+      logRestart(context->device, L"DiUninstallDriverW", bNeedRestart);
       *context->pbNeedRestart |= bNeedRestart;
+    }
     else
     {
       debugWinError(L"DiUninstallDriverW", GetLastError());
@@ -437,11 +855,23 @@ uninstall:
   return true;
 }
 
-bool destroyDevice(const DeviceDesc *device, LPBOOL pbNeedRestart)
+bool destroyDevice(
+  const DeviceDesc *device,
+  LPBOOL pbNeedRestart,
+  bool *deviceRemoved)
 {
-  DeviceRemovalContext context = { pbNeedRestart, true };
+  DeviceRemovalContext context =
+  {
+    .device        = device,
+    .pbNeedRestart = pbNeedRestart,
+    .success       = true,
+  };
 
-  return findDevice(device, destroyDeviceEnum, &context) && context.success;
+  const bool found = findDevice(device, destroyDeviceEnum, &context);
+  if (deviceRemoved)
+    *deviceRemoved = context.deviceRemoved;
+
+  return found && context.success;
 }
 
 bool getInfPath(const DeviceDesc *device, LPWSTR lpszInf)
@@ -481,6 +911,43 @@ bool getInfPath(const DeviceDesc *device, LPWSTR lpszInf)
   return true;
 }
 
+bool stageInf(DeviceRuntimeState *state)
+{
+  WCHAR sourceInf[MAX_PATH];
+  state->stagedInfPath[0] = 0;
+
+  if (!getInfPath(state->device, sourceInf))
+    return false;
+
+  // NOOVERWRITE distinguishes packages introduced by this transaction
+  // from packages that must survive a failed fresh installation.
+  if (SetupCopyOEMInfW(sourceInf, NULL, SPOST_PATH,
+      SP_COPY_NOOVERWRITE, state->stagedInfPath,
+      ARRAYSIZE(state->stagedInfPath), NULL, NULL))
+  {
+    wprintf(L"%s: staged new package as %s\n",
+      state->device->name, state->stagedInfPath);
+    return true;
+  }
+
+  const DWORD error = GetLastError();
+  if (error == ERROR_FILE_EXISTS)
+  {
+    if (*state->stagedInfPath)
+      wprintf(L"%s: package already staged as %s\n",
+        state->device->name, state->stagedInfPath);
+    else
+      wprintf(L"%s: package is already staged\n",
+        state->device->name);
+    state->stagedInfPath[0] = 0;
+    return true;
+  }
+
+  state->stagedInfPath[0] = 0;
+  debugWinError(L"SetupCopyOEMInfW", error);
+  return false;
+}
+
 bool installInf(const DeviceDesc *device, PBOOL pbNeedRestart)
 {
   WCHAR szInf[MAX_PATH];
@@ -497,65 +964,274 @@ bool installInf(const DeviceDesc *device, PBOOL pbNeedRestart)
   return true;
 }
 
+bool removeCreatedDevice(
+  const DeviceRuntimeState *state,
+  LPBOOL pbNeedRestart)
+{
+  HDEVINFO hDevInfo = SetupDiCreateDeviceInfoList(
+    state->device->classGuid, NULL);
+  if (hDevInfo == INVALID_HANDLE_VALUE)
+  {
+    debugWinError(L"SetupDiCreateDeviceInfoList", GetLastError());
+    return false;
+  }
+
+  SP_DEVINFO_DATA devInfo = { .cbSize = sizeof devInfo };
+  if (!SetupDiOpenDeviceInfoW(hDevInfo, state->instanceId,
+      NULL, 0, &devInfo))
+  {
+    const DWORD error = GetLastError();
+    SetupDiDestroyDeviceInfoList(hDevInfo);
+    if (error == ERROR_NO_SUCH_DEVINST)
+      return true;
+    debugWinError(L"SetupDiOpenDeviceInfoW", error);
+    return false;
+  }
+
+  BOOL callNeedRestart = FALSE;
+  if (!DiUninstallDevice(NULL, hDevInfo, &devInfo, 0,
+      &callNeedRestart))
+  {
+    const DWORD error = GetLastError();
+    SetupDiDestroyDeviceInfoList(hDevInfo);
+    debugWinError(L"DiUninstallDevice (rollback)", error);
+    return false;
+  }
+
+  SetupDiDestroyDeviceInfoList(hDevInfo);
+  logRestart(state->device, L"DiUninstallDevice (rollback)",
+    callNeedRestart);
+  *pbNeedRestart |= callNeedRestart;
+  return true;
+}
+
+bool rollbackCreatedDevice(
+  DeviceRuntimeState *state,
+  LPBOOL pbNeedRestart)
+{
+  if (!state->created)
+    return true;
+
+  wprintf(L"Rolling back %s device...\n", state->device->name);
+  if (!removeCreatedDevice(state, pbNeedRestart))
+    return false;
+
+  state->rollbackDeviceSafe = true;
+  state->present = false;
+  return true;
+}
+
+bool rollbackStagedPackage(
+  DeviceRuntimeState *state,
+  LPBOOL pbNeedRestart)
+{
+  if (!*state->stagedInfPath)
+    return true;
+
+  if (state->created && !state->rollbackDeviceSafe)
+  {
+    fwprintf(stderr,
+      L"%s: retaining newly staged package because device rollback "
+      L"failed\n", state->device->name);
+    return false;
+  }
+
+  BOOL callNeedRestart = FALSE;
+  wprintf(L"Rolling back %s package...\n", state->device->name);
+  if (!DiUninstallDriverW(NULL, state->stagedInfPath, 0,
+      &callNeedRestart))
+  {
+    debugWinError(L"DiUninstallDriverW (rollback)", GetLastError());
+    return false;
+  }
+
+  logRestart(state->device, L"DiUninstallDriverW (rollback)",
+    callNeedRestart);
+  *pbNeedRestart |= callNeedRestart;
+  state->stagedInfPath[0] = 0;
+  return true;
+}
+
+bool rollbackInstall(
+  DeviceRuntimeState *idd,
+  DeviceRuntimeState *input,
+  LPBOOL pbNeedRestart)
+{
+  bool success = true;
+
+  const bool inputDeviceSafe =
+    rollbackCreatedDevice(input, pbNeedRestart);
+  if (!inputDeviceSafe)
+    success = false;
+
+  if (inputDeviceSafe)
+  {
+    if (!rollbackCreatedDevice(idd, pbNeedRestart))
+      success = false;
+  }
+  else if (idd->created)
+  {
+    fwprintf(stderr,
+      L"LGIdd: retaining newly created device because LGInput "
+      L"rollback failed\n");
+  }
+
+  bool packageOrderSafe = inputDeviceSafe;
+  if (packageOrderSafe)
+  {
+    if (!rollbackStagedPackage(input, pbNeedRestart))
+    {
+      packageOrderSafe = false;
+      success = false;
+    }
+  }
+  else if (*input->stagedInfPath)
+  {
+    fwprintf(stderr,
+      L"LGInput: retaining newly staged package because device "
+      L"rollback failed\n");
+  }
+
+  if (packageOrderSafe)
+  {
+    if (!rollbackStagedPackage(idd, pbNeedRestart))
+      success = false;
+  }
+  else if (*idd->stagedInfPath)
+  {
+    fwprintf(stderr,
+      L"LGIdd: retaining newly staged package because LGInput package "
+      L"rollback failed\n");
+    success = false;
+  }
+
+  return success;
+}
+
 void install(const DeviceDesc *const devices[DEVICE_COUNT])
 {
-  enum DeviceCreated created[DEVICE_COUNT];
+  DeviceRuntimeState idd;
+  DeviceRuntimeState input;
+  bool helperExisted = false;
+  bool helperWasRunning = false;
+  bool installSucceeded = false;
+  bool rollbackSucceeded = true;
+  bool restoreSucceeded;
+  BOOL needRestart = FALSE;
 
-  for (size_t i = 0; i < DEVICE_COUNT; ++i)
+  if (!captureDeviceState(&LGIDD_DEVICE, &idd) ||
-  {
+      !captureDeviceState(&LGINPUT_DEVICE, &input))
-    created[i] = isDeviceCreated(devices[i]);
-    if (created[i] == DEVICE_UNKNOWN)
     exit(1);
-  }
+
+  _putws(L"Stopping LGIddHelper...");
+  if (!stopHelperService(&helperExisted, &helperWasRunning))
+    exit(1);
+
+  // LGInput consumes LGIdd's input pipe, so quiesce the dependent device
+  // first and restore the provider first.
+  if (!disableDevice(&input) || !disableDevice(&idd))
+    goto cleanup;
 
   _putws(L"Preparing registry key...");
   if (!ensureKeyWithAce())
-    exit(1);
+    goto cleanup;
-
-  BOOL bNeedRestart = FALSE;
-  BOOL bInfNeedRestart = FALSE;
 
   for (size_t i = 0; i < DEVICE_COUNT; ++i)
   {
     const DeviceDesc *device = devices[i];
+    DeviceRuntimeState *state = runtimeStateForDevice(
+      device, &idd, &input);
+    BOOL callNeedRestart = FALSE;
 
-    if (created[i] == DEVICE_NOT_CREATED)
+    if (!state->present)
     {
-      wprintf(L"Preinstalling %s INF...\n", device->name);
+      wprintf(L"Staging %s INF...\n", device->name);
-      bInfNeedRestart = FALSE;
+      if (!stageInf(state))
-      if (!installInf(device, &bInfNeedRestart))
+        goto cleanup;
-        exit(1);
-      bNeedRestart |= bInfNeedRestart;
 
       wprintf(L"Creating %s device: %s...\n", device->name, device->hardwareId);
-      if (!createDevice(device))
+      if (!createDevice(state))
-        exit(1);
+        goto cleanup;
+      state->present = true;
+      state->created = true;
     }
 
     wprintf(L"Installing %s INF...\n", device->name);
-    bInfNeedRestart = FALSE;
+    callNeedRestart = FALSE;
-    if (!installInf(device, &bInfNeedRestart))
+    if (!installInf(device, &callNeedRestart))
-      exit(1);
+      goto cleanup;
-    bNeedRestart |= bInfNeedRestart;
+    logRestart(device, L"DiInstallDriverW", callNeedRestart);
+    needRestart |= callNeedRestart;
   }
 
-  if (bNeedRestart)
+  installSucceeded = true;
+
+cleanup:
+  if (!installSucceeded)
+  {
+    rollbackSucceeded = rollbackInstall(&idd, &input, &needRestart);
+    if (!helperExisted && idd.created && idd.rollbackDeviceSafe)
+    {
+      _putws(L"Removing LGIddHelper created by failed installation...");
+      if (!deleteHelperService())
+        rollbackSucceeded = false;
+    }
+  }
+
+  restoreSucceeded = enableDevices(&idd, &input);
+
+  if (installSucceeded && restoreSucceeded && !needRestart)
+  {
+    _putws(L"Starting LGIddHelper...");
+    if (!startHelperService())
+      restoreSucceeded = false;
+  }
+  else if (!installSucceeded && restoreSucceeded && helperWasRunning)
+  {
+    _putws(L"Restoring LGIddHelper after failed installation...");
+    if (!startHelperService())
+      restoreSucceeded = false;
+  }
+
+  if (!installSucceeded)
+  {
+    if (!rollbackSucceeded)
+      fwprintf(stderr, L"Installation rollback was incomplete\n");
+    if (needRestart)
+    {
+      _putws(L"Restart required after failed installation");
+      exit(EXIT_FAILURE_RESTART_REQUIRED);
+    }
+    exit(1);
+  }
+
+  if (needRestart)
   {
     _putws(L"Restart required to complete installation");
-    exit(12);
+    exit(EXIT_RESTART_REQUIRED);
   }
+
+  if (!restoreSucceeded)
+    exit(1);
 }
 
 void uninstall()
 {
-  BOOL bNeedRestart = 0;
+  BOOL bNeedRestart = FALSE;
-  bool success = true;
+  bool helperWasRunning;
+  bool iddRemoved = false;
+
+  _putws(L"Stopping LGIddHelper...");
+  if (!stopHelperService(NULL, &helperWasRunning))
+    exit(1);
 
   _putws(L"Uninstalling LGInput...");
-  success &= destroyDevice(&LGINPUT_DEVICE, &bNeedRestart);
+  if (!destroyDevice(&LGINPUT_DEVICE, &bNeedRestart, NULL))
+    goto failure;
 
   _putws(L"Uninstalling LGIdd...");
-  success &= destroyDevice(&LGIDD_DEVICE, &bNeedRestart);
+  if (!destroyDevice(&LGIDD_DEVICE, &bNeedRestart, &iddRemoved))
+    goto failure;
 
   DWORD ec = deleteKeyTreeHKLM();
   if (ec != ERROR_SUCCESS)
@@ -564,14 +1240,27 @@ void uninstall()
     // this is non-fatal
   }
 
-  if (!success)
-    exit(1);
-
   if (bNeedRestart)
   {
-    _putws(L"Restart required to complete installation");
+    _putws(L"Restart required to complete uninstallation");
-    exit(12);
+    exit(EXIT_RESTART_REQUIRED);
   }
+  return;
+
+failure:
+  if (helperWasRunning && !iddRemoved && deviceIsUsable(&LGIDD_DEVICE))
+  {
+    _putws(L"Restoring LGIddHelper after failed uninstallation...");
+    if (!startHelperService())
+      fwprintf(stderr,
+        L"LGIddHelper could not be restored after uninstall failure\n");
+  }
+  if (bNeedRestart)
+  {
+    _putws(L"Restart required after failed uninstallation");
+    exit(EXIT_FAILURE_RESTART_REQUIRED);
+  }
+  exit(1);
 }
 
 int wmain(int argc, wchar_t **argv)

idd/LGInput/LGInput.inf

@@ -60,7 +60,7 @@ ServiceBinary=%12%\UMDF\LGInput.dll
 UMDriverCopy=12,UMDF
 
 [UMDriverCopy]
-LGInput.dll
+LGInput.dll,,,0x00004000
 
 [SourceDisksNames]
 1=%DiskName%

idd/installer.nsi

@@ -50,6 +50,9 @@ InstallDir "$PROGRAMFILES64\Looking Glass (IDD)"
 !define MUI_TEXTCOLOR "ffffff"
 !define MUI_WELCOMEFINISHPAGE_BITMAP "${NSISDIR}\Contrib\Graphics\Wizard\nsis3-grey.bmp"
 !define /file VERSION "VERSION"
+!define LGIDD_EXIT_RESTART_REQUIRED 12
+; The operation failed, but a partial change or rollback still needs reboot.
+!define LGIDD_EXIT_FAILURE_RESTART_REQUIRED 13
 
 !define MUI_WELCOMEPAGE_TEXT "\
   You are about to install $(^Name) version ${VERSION}.$\n$\n\
@@ -118,18 +121,6 @@ Function .onInit
 
 FunctionEnd
 
-!macro StopLGIddHelper
-  ;Attempt to stop existing LG service only if it exists
-
-  nsExec::Exec 'sc.exe query LGIddHelper'
-  Pop $0 ; SC.exe error level
-
-  ${If} $0 == 0 ; If error level is 0, service exists
-    DetailPrint "Stop service: LGIddHelper"
-    nsExec::ExecToLog 'net.exe STOP LGIddHelper'
-  ${EndIf}
-!macroend
-
 ;Install 
 !ifdef IVSHMEM
 Section "IVSHMEM Driver" Section0
@@ -207,23 +198,44 @@ Section "!Indirect Display Driver (IDD)" Section1
   WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\Looking Glass (IDD)" \
   "DisplayVersion" ${VERSION}
 
-  !insertmacro StopLGIddHelper
-
   DetailPrint "Installing IDD"
   nsExec::ExecToLog '"$INSTDIR\LGIddInstall.exe" install'
 
   Pop $0
-  ${If} $0 == 12
+  ${If} $0 == ${LGIDD_EXIT_RESTART_REQUIRED}
     DetailPrint "Restart is required to complete driver install."
+    SetRebootFlag true
+  ${ElseIf} $0 == ${LGIDD_EXIT_FAILURE_RESTART_REQUIRED}
+    DetailPrint "Driver installation failed and a restart is required."
+    SetRebootFlag true
+    SetErrorLevel $0
+    Abort
+  ${ElseIf} $0 != 0
+    DetailPrint "Driver installation failed with exit code $0."
+    SetErrorLevel $0
+    Abort
   ${EndIf}
 
 SectionEnd
 
 Section "Uninstall" Section6
-  !insertmacro StopLGIddHelper
-
   DetailPrint "Uninstalling IDD"
   nsExec::ExecToLog '"$INSTDIR\LGIddInstall.exe" uninstall'
+  Pop $0
+
+  ${If} $0 == ${LGIDD_EXIT_RESTART_REQUIRED}
+    DetailPrint "Restart is required to complete driver uninstall."
+    SetRebootFlag true
+  ${ElseIf} $0 == ${LGIDD_EXIT_FAILURE_RESTART_REQUIRED}
+    DetailPrint "Driver uninstallation failed and a restart is required."
+    SetRebootFlag true
+    SetErrorLevel $0
+    Abort
+  ${ElseIf} $0 != 0
+    DetailPrint "Driver uninstallation failed with exit code $0."
+    SetErrorLevel $0
+    Abort
+  ${EndIf}
 
   DetailPrint "Clean up helper service"
   nsExec::Exec 'sc.exe delete LGIddHelper'