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