qga/vss-win32/requester.cpp

   1 /*
   2  * QEMU Guest Agent win32 VSS Requester implementations
   3  *
   4  * Copyright Hitachi Data Systems Corp. 2013
   5  *
   6  * Authors:
   7  *  Tomoki Sekiyama   <tomoki.sekiyama@hds.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "vss-common.h"
  15 #include "vss-debug.h"
  16 #include "requester.h"
  17 #include "install.h"
  18 #include <vswriter.h>
  19 #include <vsbackup.h>
  20
  21 /* Max wait time for frozen event (VSS can only hold writes for 10 seconds) */
  22 #define VSS_TIMEOUT_FREEZE_MSEC 60000
  23
  24 /* Call QueryStatus every 10 ms while waiting for frozen event */
  25 #define VSS_TIMEOUT_EVENT_MSEC 10
  26
  27 #define DEFAULT_VSS_BACKUP_TYPE VSS_BT_FULL
  28
  29 #define err_set(e, err, fmt, ...) {                                         \
  30     (e)->error_setg_win32_wrapper((e)->errp, __FILE__, __LINE__, __func__,  \
  31                                    err, fmt, ## __VA_ARGS__);               \
  32     qga_debug(fmt, ## __VA_ARGS__);                                         \
  33 }
  34 /* Bad idea, works only when (e)->errp != NULL: */
  35 #define err_is_set(e) ((e)->errp && *(e)->errp)
  36 /* To lift this restriction, error_propagate(), like we do in QEMU code */
  37
  38 /* Handle to VSSAPI.DLL */
  39 static HMODULE hLib;
  40
  41 /* Functions in VSSAPI.DLL */
  42 typedef HRESULT(STDAPICALLTYPE * t_CreateVssBackupComponents)(
  43     OUT IVssBackupComponents**);
  44 typedef void(APIENTRY * t_VssFreeSnapshotProperties)(IN VSS_SNAPSHOT_PROP*);
  45 static t_CreateVssBackupComponents pCreateVssBackupComponents;
  46 static t_VssFreeSnapshotProperties pVssFreeSnapshotProperties;
  47
  48 /* Variables used while applications and filesystes are frozen by VSS */
  49 static struct QGAVSSContext {
  50     IVssBackupComponents *pVssbc;  /* VSS requester interface */
  51     IVssAsync *pAsyncSnapshot;     /* async info of VSS snapshot operation */
  52     HANDLE hEventFrozen;           /* notify fs/writer freeze from provider */
  53     HANDLE hEventThaw;             /* request provider to thaw */
  54     HANDLE hEventTimeout;          /* notify timeout in provider */
  55     int cFrozenVols;               /* number of frozen volumes */
  56 } vss_ctx;
  57
  58 STDAPI requester_init(void)
  59 {
  60     qga_debug_begin;
  61
  62     COMInitializer initializer; /* to call CoInitializeSecurity */
  63     HRESULT hr = CoInitializeSecurity(
  64         NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
  65         RPC_C_IMP_LEVEL_IDENTIFY, NULL, EOAC_NONE, NULL);
  66     if (FAILED(hr)) {
  67         qga_debug("failed to CoInitializeSecurity (error %lx)", hr);
  68         return hr;
  69     }
  70
  71     hLib = LoadLibraryA("VSSAPI.DLL");
  72     if (!hLib) {
  73         qga_debug("failed to load VSSAPI.DLL");
  74         return HRESULT_FROM_WIN32(GetLastError());
  75     }
  76
  77     pCreateVssBackupComponents = (t_CreateVssBackupComponents)
  78         GetProcAddress(hLib,
  79 #ifdef _WIN64 /* 64bit environment */
  80         "?CreateVssBackupComponents@@YAJPEAPEAVIVssBackupComponents@@@Z"
  81 #else /* 32bit environment */
  82         "?CreateVssBackupComponents@@YGJPAPAVIVssBackupComponents@@@Z"
  83 #endif
  84         );
  85     if (!pCreateVssBackupComponents) {
  86         qga_debug("failed to get proc address from VSSAPI.DLL");
  87         return HRESULT_FROM_WIN32(GetLastError());
  88     }
  89
  90     pVssFreeSnapshotProperties = (t_VssFreeSnapshotProperties)
  91         GetProcAddress(hLib, "VssFreeSnapshotProperties");
  92     if (!pVssFreeSnapshotProperties) {
  93         qga_debug("failed to get proc address from VSSAPI.DLL");
  94         return HRESULT_FROM_WIN32(GetLastError());
  95     }
  96
  97     qga_debug_end;
  98     return S_OK;
  99 }
 100
 101 static void requester_cleanup(void)
 102 {
 103     qga_debug_begin;
 104
 105     if (vss_ctx.hEventFrozen) {
 106         CloseHandle(vss_ctx.hEventFrozen);
 107         vss_ctx.hEventFrozen = NULL;
 108     }
 109     if (vss_ctx.hEventThaw) {
 110         CloseHandle(vss_ctx.hEventThaw);
 111         vss_ctx.hEventThaw = NULL;
 112     }
 113     if (vss_ctx.hEventTimeout) {
 114         CloseHandle(vss_ctx.hEventTimeout);
 115         vss_ctx.hEventTimeout = NULL;
 116     }
 117     if (vss_ctx.pAsyncSnapshot) {
 118         vss_ctx.pAsyncSnapshot->Release();
 119         vss_ctx.pAsyncSnapshot = NULL;
 120     }
 121     if (vss_ctx.pVssbc) {
 122         vss_ctx.pVssbc->Release();
 123         vss_ctx.pVssbc = NULL;
 124     }
 125     vss_ctx.cFrozenVols = 0;
 126     qga_debug_end;
 127 }
 128
 129 STDAPI requester_deinit(void)
 130 {
 131     qga_debug_begin;
 132
 133     requester_cleanup();
 134
 135     pCreateVssBackupComponents = NULL;
 136     pVssFreeSnapshotProperties = NULL;
 137     if (hLib) {
 138         FreeLibrary(hLib);
 139         hLib = NULL;
 140     }
 141
 142     qga_debug_end;
 143     return S_OK;
 144 }
 145
 146 static HRESULT WaitForAsync(IVssAsync *pAsync)
 147 {
 148     qga_debug_begin;
 149
 150     HRESULT ret, hr;
 151
 152     do {
 153         hr = pAsync->Wait();
 154         if (FAILED(hr)) {
 155             ret = hr;
 156             break;
 157         }
 158         hr = pAsync->QueryStatus(&ret, NULL);
 159         if (FAILED(hr)) {
 160             ret = hr;
 161             break;
 162         }
 163     } while (ret == VSS_S_ASYNC_PENDING);
 164
 165     qga_debug_end;
 166     return ret;
 167 }
 168
 169 static void AddComponents(ErrorSet *errset)
 170 {
 171     qga_debug_begin;
 172
 173     unsigned int cWriters, i;
 174     VSS_ID id, idInstance, idWriter;
 175     BSTR bstrWriterName = NULL;
 176     VSS_USAGE_TYPE usage;
 177     VSS_SOURCE_TYPE source;
 178     unsigned int cComponents, c1, c2, j;
 179     COMPointer<IVssExamineWriterMetadata> pMetadata;
 180     COMPointer<IVssWMComponent> pComponent;
 181     PVSSCOMPONENTINFO info;
 182     HRESULT hr;
 183
 184     hr = vss_ctx.pVssbc->GetWriterMetadataCount(&cWriters);
 185     if (FAILED(hr)) {
 186         err_set(errset, hr, "failed to get writer metadata count");
 187         goto out;
 188     }
 189
 190     for (i = 0; i < cWriters; i++) {
 191         hr = vss_ctx.pVssbc->GetWriterMetadata(i, &id, pMetadata.replace());
 192         if (FAILED(hr)) {
 193             err_set(errset, hr, "failed to get writer metadata of %d/%d",
 194                              i, cWriters);
 195             goto out;
 196         }
 197
 198         hr = pMetadata->GetIdentity(&idInstance, &idWriter,
 199                                     &bstrWriterName, &usage, &source);
 200         if (FAILED(hr)) {
 201             err_set(errset, hr, "failed to get identity of writer %d/%d",
 202                              i, cWriters);
 203             goto out;
 204         }
 205
 206         hr = pMetadata->GetFileCounts(&c1, &c2, &cComponents);
 207         if (FAILED(hr)) {
 208             err_set(errset, hr, "failed to get file counts of %S",
 209                              bstrWriterName);
 210             goto out;
 211         }
 212
 213         for (j = 0; j < cComponents; j++) {
 214             hr = pMetadata->GetComponent(j, pComponent.replace());
 215             if (FAILED(hr)) {
 216                 err_set(errset, hr,
 217                                  "failed to get component %d/%d of %S",
 218                                  j, cComponents, bstrWriterName);
 219                 goto out;
 220             }
 221
 222             hr = pComponent->GetComponentInfo(&info);
 223             if (FAILED(hr)) {
 224                 err_set(errset, hr,
 225                                  "failed to get component info %d/%d of %S",
 226                                  j, cComponents, bstrWriterName);
 227                 goto out;
 228             }
 229
 230             if (info->bSelectable) {
 231                 hr = vss_ctx.pVssbc->AddComponent(idInstance, idWriter,
 232                                                   info->type,
 233                                                   info->bstrLogicalPath,
 234                                                   info->bstrComponentName);
 235                 if (FAILED(hr)) {
 236                     err_set(errset, hr, "failed to add component %S(%S)",
 237                                      info->bstrComponentName, bstrWriterName);
 238                     goto out;
 239                 }
 240             }
 241             SysFreeString(bstrWriterName);
 242             bstrWriterName = NULL;
 243             pComponent->FreeComponentInfo(info);
 244             info = NULL;
 245         }
 246     }
 247 out:
 248     if (bstrWriterName) {
 249         SysFreeString(bstrWriterName);
 250     }
 251     if (pComponent && info) {
 252         pComponent->FreeComponentInfo(info);
 253     }
 254     qga_debug_end;
 255 }
 256
 257 DWORD get_reg_dword_value(HKEY baseKey, LPCSTR subKey, LPCSTR valueName,
 258                           DWORD defaultData)
 259 {
 260     qga_debug_begin;
 261
 262     DWORD regGetValueError;
 263     DWORD dwordData;
 264     DWORD dataSize = sizeof(DWORD);
 265
 266     regGetValueError = RegGetValue(baseKey, subKey, valueName, RRF_RT_DWORD,
 267                                    NULL, &dwordData, &dataSize);
 268     qga_debug_end;
 269     if (regGetValueError  != ERROR_SUCCESS) {
 270         return defaultData;
 271     }
 272     return dwordData;
 273 }
 274
 275 bool is_valid_vss_backup_type(VSS_BACKUP_TYPE vssBT)
 276 {
 277     return (vssBT > VSS_BT_UNDEFINED && vssBT < VSS_BT_OTHER);
 278 }
 279
 280 VSS_BACKUP_TYPE get_vss_backup_type(
 281     VSS_BACKUP_TYPE defaultVssBT = DEFAULT_VSS_BACKUP_TYPE)
 282 {
 283     qga_debug_begin;
 284
 285     VSS_BACKUP_TYPE vssBackupType;
 286
 287     vssBackupType = static_cast<VSS_BACKUP_TYPE>(
 288                             get_reg_dword_value(HKEY_LOCAL_MACHINE,
 289                                                 QGA_PROVIDER_REGISTRY_ADDRESS,
 290                                                 "VssOption",
 291                                                 defaultVssBT));
 292     qga_debug_end;
 293     if (!is_valid_vss_backup_type(vssBackupType)) {
 294         return defaultVssBT;
 295     }
 296     return vssBackupType;
 297 }
 298
 299 void requester_freeze(int *num_vols, void *mountpoints, ErrorSet *errset)
 300 {
 301     qga_debug_begin;
 302
 303     COMPointer<IVssAsync> pAsync;
 304     HANDLE volume;
 305     HRESULT hr;
 306     LONG ctx;
 307     GUID guidSnapshotSet = GUID_NULL;
 308     SECURITY_DESCRIPTOR sd;
 309     SECURITY_ATTRIBUTES sa;
 310     WCHAR short_volume_name[64], *display_name = short_volume_name;
 311     DWORD wait_status;
 312     int num_fixed_drives = 0, i;
 313     int num_mount_points = 0;
 314     VSS_BACKUP_TYPE vss_bt = get_vss_backup_type();
 315
 316     if (vss_ctx.pVssbc) { /* already frozen */
 317         *num_vols = 0;
 318         qga_debug("finished, already frozen");
 319         return;
 320     }
 321
 322     CoInitialize(NULL);
 323
 324     /* Allow unrestricted access to events */
 325     InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
 326     SetSecurityDescriptorDacl(&sd, TRUE, NULL, FALSE);
 327     sa.nLength = sizeof(sa);
 328     sa.lpSecurityDescriptor = &sd;
 329     sa.bInheritHandle = FALSE;
 330
 331     vss_ctx.hEventFrozen = CreateEvent(&sa, TRUE, FALSE, EVENT_NAME_FROZEN);
 332     if (!vss_ctx.hEventFrozen) {
 333         err_set(errset, GetLastError(), "failed to create event %s",
 334                 EVENT_NAME_FROZEN);
 335         goto out;
 336     }
 337     vss_ctx.hEventThaw = CreateEvent(&sa, TRUE, FALSE, EVENT_NAME_THAW);
 338     if (!vss_ctx.hEventThaw) {
 339         err_set(errset, GetLastError(), "failed to create event %s",
 340                 EVENT_NAME_THAW);
 341         goto out;
 342     }
 343     vss_ctx.hEventTimeout = CreateEvent(&sa, TRUE, FALSE, EVENT_NAME_TIMEOUT);
 344     if (!vss_ctx.hEventTimeout) {
 345         err_set(errset, GetLastError(), "failed to create event %s",
 346                 EVENT_NAME_TIMEOUT);
 347         goto out;
 348     }
 349
 350     assert(pCreateVssBackupComponents != NULL);
 351     hr = pCreateVssBackupComponents(&vss_ctx.pVssbc);
 352     if (FAILED(hr)) {
 353         err_set(errset, hr, "failed to create VSS backup components");
 354         goto out;
 355     }
 356
 357     hr = vss_ctx.pVssbc->InitializeForBackup();
 358     if (FAILED(hr)) {
 359         err_set(errset, hr, "failed to initialize for backup");
 360         goto out;
 361     }
 362
 363     hr = vss_ctx.pVssbc->SetBackupState(true, true, vss_bt, false);
 364     if (FAILED(hr)) {
 365         err_set(errset, hr, "failed to set backup state");
 366         goto out;
 367     }
 368
 369     /*
 370      * Currently writable snapshots are not supported.
 371      * To prevent the final commit (which requires to write to snapshots),
 372      * ATTR_NO_AUTORECOVERY and ATTR_TRANSPORTABLE are specified here.
 373      */
 374     ctx = VSS_CTX_APP_ROLLBACK | VSS_VOLSNAP_ATTR_TRANSPORTABLE |
 375         VSS_VOLSNAP_ATTR_NO_AUTORECOVERY | VSS_VOLSNAP_ATTR_TXF_RECOVERY;
 376     hr = vss_ctx.pVssbc->SetContext(ctx);
 377     if (hr == (HRESULT)VSS_E_UNSUPPORTED_CONTEXT) {
 378         /* Non-server version of Windows doesn't support ATTR_TRANSPORTABLE */
 379         ctx &= ~VSS_VOLSNAP_ATTR_TRANSPORTABLE;
 380         hr = vss_ctx.pVssbc->SetContext(ctx);
 381     }
 382     if (FAILED(hr)) {
 383         err_set(errset, hr, "failed to set backup context");
 384         goto out;
 385     }
 386
 387     hr = vss_ctx.pVssbc->GatherWriterMetadata(pAsync.replace());
 388     if (SUCCEEDED(hr)) {
 389         hr = WaitForAsync(pAsync);
 390     }
 391     if (FAILED(hr)) {
 392         err_set(errset, hr, "failed to gather writer metadata");
 393         goto out;
 394     }
 395
 396     AddComponents(errset);
 397     if (err_is_set(errset)) {
 398         goto out;
 399     }
 400
 401     hr = vss_ctx.pVssbc->StartSnapshotSet(&guidSnapshotSet);
 402     if (FAILED(hr)) {
 403         err_set(errset, hr, "failed to start snapshot set");
 404         goto out;
 405     }
 406
 407     if (mountpoints) {
 408         PWCHAR volume_name_wchar;
 409         for (volList *list = (volList *)mountpoints; list; list = list->next) {
 410             size_t len = strlen(list->value) + 1;
 411             size_t converted = 0;
 412             VSS_ID pid;
 413
 414             volume_name_wchar = new wchar_t[len];
 415             mbstowcs_s(&converted, volume_name_wchar, len,
 416                        list->value, _TRUNCATE);
 417
 418             hr = vss_ctx.pVssbc->AddToSnapshotSet(volume_name_wchar,
 419                                                   g_gProviderId, &pid);
 420             if (FAILED(hr)) {
 421                 err_set(errset, hr, "failed to add %S to snapshot set",
 422                         volume_name_wchar);
 423                 delete[] volume_name_wchar;
 424                 goto out;
 425             }
 426             num_mount_points++;
 427
 428             delete[] volume_name_wchar;
 429         }
 430
 431         if (num_mount_points == 0) {
 432             /* If there is no valid mount points, just exit. */
 433             goto out;
 434         }
 435     }
 436
 437     if (!mountpoints) {
 438         volume = FindFirstVolumeW(short_volume_name, sizeof(short_volume_name));
 439         if (volume == INVALID_HANDLE_VALUE) {
 440             err_set(errset, hr, "failed to find first volume");
 441             goto out;
 442         }
 443
 444         for (;;) {
 445             if (GetDriveTypeW(short_volume_name) == DRIVE_FIXED) {
 446                 VSS_ID pid;
 447                 hr = vss_ctx.pVssbc->AddToSnapshotSet(short_volume_name,
 448                                                       g_gProviderId, &pid);
 449                 if (FAILED(hr)) {
 450                     WCHAR volume_path_name[PATH_MAX];
 451                     if (GetVolumePathNamesForVolumeNameW(
 452                             short_volume_name, volume_path_name,
 453                             sizeof(volume_path_name), NULL) &&
 454                             *volume_path_name) {
 455                         display_name = volume_path_name;
 456                     }
 457                     err_set(errset, hr, "failed to add %S to snapshot set",
 458                             display_name);
 459                     FindVolumeClose(volume);
 460                     goto out;
 461                 }
 462                 num_fixed_drives++;
 463             }
 464             if (!FindNextVolumeW(volume, short_volume_name,
 465                                  sizeof(short_volume_name))) {
 466                 FindVolumeClose(volume);
 467                 break;
 468             }
 469         }
 470
 471         if (num_fixed_drives == 0) {
 472             goto out; /* If there is no fixed drive, just exit. */
 473         }
 474     }
 475
 476     qga_debug("preparing for backup");
 477     hr = vss_ctx.pVssbc->PrepareForBackup(pAsync.replace());
 478     if (SUCCEEDED(hr)) {
 479         hr = WaitForAsync(pAsync);
 480     }
 481     if (FAILED(hr)) {
 482         err_set(errset, hr, "failed to prepare for backup");
 483         goto out;
 484     }
 485
 486     hr = vss_ctx.pVssbc->GatherWriterStatus(pAsync.replace());
 487     if (SUCCEEDED(hr)) {
 488         hr = WaitForAsync(pAsync);
 489     }
 490     if (FAILED(hr)) {
 491         err_set(errset, hr, "failed to gather writer status");
 492         goto out;
 493     }
 494
 495     /*
 496      * Start VSS quiescing operations.
 497      * CQGAVssProvider::CommitSnapshots will kick vss_ctx.hEventFrozen
 498      * after the applications and filesystems are frozen.
 499      */
 500     qga_debug("do snapshot set");
 501     hr = vss_ctx.pVssbc->DoSnapshotSet(&vss_ctx.pAsyncSnapshot);
 502     if (FAILED(hr)) {
 503         err_set(errset, hr, "failed to do snapshot set");
 504         goto out;
 505     }
 506
 507     /* Need to call QueryStatus several times to make VSS provider progress */
 508     for (i = 0; i < VSS_TIMEOUT_FREEZE_MSEC/VSS_TIMEOUT_EVENT_MSEC; i++) {
 509         HRESULT hr2 = vss_ctx.pAsyncSnapshot->QueryStatus(&hr, NULL);
 510         if (FAILED(hr2)) {
 511             err_set(errset, hr, "failed to do snapshot set");
 512             goto out;
 513         }
 514         if (hr != VSS_S_ASYNC_PENDING) {
 515             err_set(errset, E_FAIL,
 516                     "DoSnapshotSet exited without Frozen event");
 517             goto out;
 518         }
 519         wait_status = WaitForSingleObject(vss_ctx.hEventFrozen,
 520                                           VSS_TIMEOUT_EVENT_MSEC);
 521         if (wait_status != WAIT_TIMEOUT) {
 522             break;
 523         }
 524     }
 525
 526     if (wait_status == WAIT_TIMEOUT) {
 527         err_set(errset, E_FAIL,
 528                 "timeout when try to receive Frozen event from VSS provider");
 529         /* If we are here, VSS had timeout.
 530          * Don't call AbortBackup, just return directly.
 531          */
 532         goto out1;
 533     }
 534
 535     if (wait_status != WAIT_OBJECT_0) {
 536         err_set(errset, E_FAIL,
 537                 "couldn't receive Frozen event from VSS provider");
 538         goto out;
 539     }
 540
 541     if (mountpoints) {
 542         *num_vols = vss_ctx.cFrozenVols = num_mount_points;
 543     } else {
 544         *num_vols = vss_ctx.cFrozenVols = num_fixed_drives;
 545     }
 546
 547     qga_debug("end successful");
 548     return;
 549
 550 out:
 551     if (vss_ctx.pVssbc) {
 552         vss_ctx.pVssbc->AbortBackup();
 553     }
 554
 555 out1:
 556     requester_cleanup();
 557     CoUninitialize();
 558
 559     qga_debug_end;
 560 }
 561
 562
 563 void requester_thaw(int *num_vols, void *mountpints, ErrorSet *errset)
 564 {
 565     qga_debug_begin;
 566     COMPointer<IVssAsync> pAsync;
 567
 568     if (!vss_ctx.hEventThaw) {
 569         /*
 570          * In this case, DoSnapshotSet is aborted or not started,
 571          * and no volumes must be frozen. We return without an error.
 572          */
 573         *num_vols = 0;
 574         qga_debug("finished, no volumes were frozen");
 575
 576         return;
 577     }
 578
 579     /* Tell the provider that the snapshot is finished. */
 580     SetEvent(vss_ctx.hEventThaw);
 581
 582     assert(vss_ctx.pVssbc);
 583     assert(vss_ctx.pAsyncSnapshot);
 584
 585     HRESULT hr = WaitForAsync(vss_ctx.pAsyncSnapshot);
 586     switch (hr) {
 587     case VSS_S_ASYNC_FINISHED:
 588         hr = vss_ctx.pVssbc->BackupComplete(pAsync.replace());
 589         if (SUCCEEDED(hr)) {
 590             hr = WaitForAsync(pAsync);
 591         }
 592         if (FAILED(hr)) {
 593             err_set(errset, hr, "failed to complete backup");
 594         }
 595         break;
 596
 597     case (HRESULT)VSS_E_OBJECT_NOT_FOUND:
 598         /*
 599          * On Windows earlier than 2008 SP2 which does not support
 600          * VSS_VOLSNAP_ATTR_NO_AUTORECOVERY context, the final commit is not
 601          * skipped and VSS is aborted by VSS_E_OBJECT_NOT_FOUND. However, as
 602          * the system had been frozen until fsfreeze-thaw command was issued,
 603          * we ignore this error.
 604          */
 605         vss_ctx.pVssbc->AbortBackup();
 606         break;
 607
 608     case VSS_E_UNEXPECTED_PROVIDER_ERROR:
 609         if (WaitForSingleObject(vss_ctx.hEventTimeout, 0) != WAIT_OBJECT_0) {
 610             err_set(errset, hr, "unexpected error in VSS provider");
 611             break;
 612         }
 613         /* fall through if hEventTimeout is signaled */
 614
 615     case (HRESULT)VSS_E_HOLD_WRITES_TIMEOUT:
 616         err_set(errset, hr, "couldn't hold writes: "
 617                 "fsfreeze is limited up to 10 seconds");
 618         break;
 619
 620     default:
 621         err_set(errset, hr, "failed to do snapshot set");
 622     }
 623
 624     if (err_is_set(errset)) {
 625         vss_ctx.pVssbc->AbortBackup();
 626     }
 627     *num_vols = vss_ctx.cFrozenVols;
 628     requester_cleanup();
 629
 630     CoUninitialize();
 631     StopService();
 632
 633     qga_debug_end;
 634 }