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