xref: /openbmc/qemu/qga/vss-win32/provider.cpp (revision 7c08eefc) 
1 /*
2  * QEMU Guest Agent win32 VSS Provider 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 #ifdef HAVE_VSS_SDK
17 #include <vscoordint.h>
18 #else
19 #include <vsadmin.h>
20 #endif
21 #include <vsprov.h>
22 
23 #define VSS_TIMEOUT_MSEC (60*1000)
24 
25 static long g_nComObjsInUse;
26 HINSTANCE g_hinstDll;
27 
28 /* VSS common GUID's */
29 
30 const CLSID CLSID_VSSCoordinator = { 0xE579AB5F, 0x1CC4, 0x44b4,
31     {0xBE, 0xD9, 0xDE, 0x09, 0x91, 0xFF, 0x06, 0x23} };
32 const IID IID_IVssAdmin = { 0x77ED5996, 0x2F63, 0x11d3,
33     {0x8A, 0x39, 0x00, 0xC0, 0x4F, 0x72, 0xD8, 0xE3} };
34 
35 const IID IID_IVssHardwareSnapshotProvider = { 0x9593A157, 0x44E9, 0x4344,
36     {0xBB, 0xEB, 0x44, 0xFB, 0xF9, 0xB0, 0x6B, 0x10} };
37 const IID IID_IVssSoftwareSnapshotProvider = { 0x609e123e, 0x2c5a, 0x44d3,
38     {0x8f, 0x01, 0x0b, 0x1d, 0x9a, 0x47, 0xd1, 0xff} };
39 const IID IID_IVssProviderCreateSnapshotSet = { 0x5F894E5B, 0x1E39, 0x4778,
40     {0x8E, 0x23, 0x9A, 0xBA, 0xD9, 0xF0, 0xE0, 0x8C} };
41 const IID IID_IVssProviderNotifications = { 0xE561901F, 0x03A5, 0x4afe,
42     {0x86, 0xD0, 0x72, 0xBA, 0xEE, 0xCE, 0x70, 0x04} };
43 
44 const IID IID_IVssEnumObject = { 0xAE1C7110, 0x2F60, 0x11d3,
45     {0x8A, 0x39, 0x00, 0xC0, 0x4F, 0x72, 0xD8, 0xE3} };
46 
47 
48 void LockModule(BOOL lock)
49 {
50     if (lock) {
51         InterlockedIncrement(&g_nComObjsInUse);
52     } else {
53         InterlockedDecrement(&g_nComObjsInUse);
54     }
55 }
56 
57 /* Empty enumerator for VssObject */
58 
59 class CQGAVSSEnumObject : public IVssEnumObject
60 {
61 public:
62     STDMETHODIMP QueryInterface(REFIID riid, void **ppObj);
63     STDMETHODIMP_(ULONG) AddRef();
64     STDMETHODIMP_(ULONG) Release();
65 
66     /* IVssEnumObject Methods */
67     STDMETHODIMP Next(
68         ULONG celt, VSS_OBJECT_PROP *rgelt, ULONG *pceltFetched);
69     STDMETHODIMP Skip(ULONG celt);
70     STDMETHODIMP Reset(void);
71     STDMETHODIMP Clone(IVssEnumObject **ppenum);
72 
73     /* CQGAVSSEnumObject Methods */
74     CQGAVSSEnumObject();
75     ~CQGAVSSEnumObject();
76 
77 private:
78     long m_nRefCount;
79 };
80 
81 CQGAVSSEnumObject::CQGAVSSEnumObject()
82 {
83     m_nRefCount = 0;
84     LockModule(TRUE);
85 }
86 
87 CQGAVSSEnumObject::~CQGAVSSEnumObject()
88 {
89     LockModule(FALSE);
90 }
91 
92 STDMETHODIMP CQGAVSSEnumObject::QueryInterface(REFIID riid, void **ppObj)
93 {
94     if (riid == IID_IUnknown || riid == IID_IVssEnumObject) {
95         *ppObj = static_cast<void*>(static_cast<IVssEnumObject*>(this));
96         AddRef();
97         return S_OK;
98     }
99     *ppObj = NULL;
100     return E_NOINTERFACE;
101 }
102 
103 STDMETHODIMP_(ULONG) CQGAVSSEnumObject::AddRef()
104 {
105     return InterlockedIncrement(&m_nRefCount);
106 }
107 
108 STDMETHODIMP_(ULONG) CQGAVSSEnumObject::Release()
109 {
110     long nRefCount = InterlockedDecrement(&m_nRefCount);
111     if (m_nRefCount == 0) {
112         delete this;
113     }
114     return nRefCount;
115 }
116 
117 STDMETHODIMP CQGAVSSEnumObject::Next(
118     ULONG celt, VSS_OBJECT_PROP *rgelt, ULONG *pceltFetched)
119 {
120     *pceltFetched = 0;
121     return S_FALSE;
122 }
123 
124 STDMETHODIMP CQGAVSSEnumObject::Skip(ULONG celt)
125 {
126     return S_FALSE;
127 }
128 
129 STDMETHODIMP CQGAVSSEnumObject::Reset(void)
130 {
131     return S_OK;
132 }
133 
134 STDMETHODIMP CQGAVSSEnumObject::Clone(IVssEnumObject **ppenum)
135 {
136     return E_NOTIMPL;
137 }
138 
139 
140 /* QGAVssProvider */
141 
142 class CQGAVssProvider :
143     public IVssSoftwareSnapshotProvider,
144     public IVssProviderCreateSnapshotSet,
145     public IVssProviderNotifications
146 {
147 public:
148     STDMETHODIMP QueryInterface(REFIID riid, void **ppObj);
149     STDMETHODIMP_(ULONG) AddRef();
150     STDMETHODIMP_(ULONG) Release();
151 
152     /* IVssSoftwareSnapshotProvider Methods */
153     STDMETHODIMP SetContext(LONG lContext);
154     STDMETHODIMP GetSnapshotProperties(
155         VSS_ID SnapshotId, VSS_SNAPSHOT_PROP *pProp);
156     STDMETHODIMP Query(
157         VSS_ID QueriedObjectId, VSS_OBJECT_TYPE eQueriedObjectType,
158         VSS_OBJECT_TYPE eReturnedObjectsType, IVssEnumObject **ppEnum);
159     STDMETHODIMP DeleteSnapshots(
160         VSS_ID SourceObjectId, VSS_OBJECT_TYPE eSourceObjectType,
161         BOOL bForceDelete, LONG *plDeletedSnapshots,
162         VSS_ID *pNondeletedSnapshotID);
163     STDMETHODIMP BeginPrepareSnapshot(
164         VSS_ID SnapshotSetId, VSS_ID SnapshotId,
165         VSS_PWSZ pwszVolumeName, LONG lNewContext);
166     STDMETHODIMP IsVolumeSupported(
167         VSS_PWSZ pwszVolumeName, BOOL *pbSupportedByThisProvider);
168     STDMETHODIMP IsVolumeSnapshotted(
169         VSS_PWSZ pwszVolumeName, BOOL *pbSnapshotsPresent,
170         LONG *plSnapshotCompatibility);
171     STDMETHODIMP SetSnapshotProperty(
172         VSS_ID SnapshotId, VSS_SNAPSHOT_PROPERTY_ID eSnapshotPropertyId,
173         VARIANT vProperty);
174     STDMETHODIMP RevertToSnapshot(VSS_ID SnapshotId);
175     STDMETHODIMP QueryRevertStatus(VSS_PWSZ pwszVolume, IVssAsync **ppAsync);
176 
177     /* IVssProviderCreateSnapshotSet Methods */
178     STDMETHODIMP EndPrepareSnapshots(VSS_ID SnapshotSetId);
179     STDMETHODIMP PreCommitSnapshots(VSS_ID SnapshotSetId);
180     STDMETHODIMP CommitSnapshots(VSS_ID SnapshotSetId);
181     STDMETHODIMP PostCommitSnapshots(
182         VSS_ID SnapshotSetId, LONG lSnapshotsCount);
183     STDMETHODIMP PreFinalCommitSnapshots(VSS_ID SnapshotSetId);
184     STDMETHODIMP PostFinalCommitSnapshots(VSS_ID SnapshotSetId);
185     STDMETHODIMP AbortSnapshots(VSS_ID SnapshotSetId);
186 
187     /* IVssProviderNotifications Methods */
188     STDMETHODIMP OnLoad(IUnknown *pCallback);
189     STDMETHODIMP OnUnload(BOOL bForceUnload);
190 
191     /* CQGAVssProvider Methods */
192     CQGAVssProvider();
193     ~CQGAVssProvider();
194 
195 private:
196     long m_nRefCount;
197 };
198 
199 CQGAVssProvider::CQGAVssProvider()
200 {
201     m_nRefCount = 0;
202     LockModule(TRUE);
203 }
204 
205 CQGAVssProvider::~CQGAVssProvider()
206 {
207     LockModule(FALSE);
208 }
209 
210 STDMETHODIMP CQGAVssProvider::QueryInterface(REFIID riid, void **ppObj)
211 {
212     if (riid == IID_IUnknown) {
213         *ppObj = static_cast<void*>(this);
214         AddRef();
215         return S_OK;
216     }
217     if (riid == IID_IVssSoftwareSnapshotProvider) {
218         *ppObj = static_cast<void*>(
219             static_cast<IVssSoftwareSnapshotProvider*>(this));
220         AddRef();
221         return S_OK;
222     }
223     if (riid == IID_IVssProviderCreateSnapshotSet) {
224         *ppObj = static_cast<void*>(
225             static_cast<IVssProviderCreateSnapshotSet*>(this));
226         AddRef();
227         return S_OK;
228     }
229     if (riid == IID_IVssProviderNotifications) {
230         *ppObj = static_cast<void*>(
231             static_cast<IVssProviderNotifications*>(this));
232         AddRef();
233         return S_OK;
234     }
235     *ppObj = NULL;
236     return E_NOINTERFACE;
237 }
238 
239 STDMETHODIMP_(ULONG) CQGAVssProvider::AddRef()
240 {
241     return InterlockedIncrement(&m_nRefCount);
242 }
243 
244 STDMETHODIMP_(ULONG) CQGAVssProvider::Release()
245 {
246     long nRefCount = InterlockedDecrement(&m_nRefCount);
247     if (m_nRefCount == 0) {
248         delete this;
249     }
250     return nRefCount;
251 }
252 
253 
254 /*
255  * IVssSoftwareSnapshotProvider methods
256  */
257 
258 STDMETHODIMP CQGAVssProvider::SetContext(LONG lContext)
259 {
260     return S_OK;
261 }
262 
263 STDMETHODIMP CQGAVssProvider::GetSnapshotProperties(
264     VSS_ID SnapshotId, VSS_SNAPSHOT_PROP *pProp)
265 {
266     return VSS_E_OBJECT_NOT_FOUND;
267 }
268 
269 STDMETHODIMP CQGAVssProvider::Query(
270     VSS_ID QueriedObjectId, VSS_OBJECT_TYPE eQueriedObjectType,
271     VSS_OBJECT_TYPE eReturnedObjectsType, IVssEnumObject **ppEnum)
272 {
273     try {
274         *ppEnum = new CQGAVSSEnumObject;
275     } catch (...) {
276         return E_OUTOFMEMORY;
277     }
278     (*ppEnum)->AddRef();
279     return S_OK;
280 }
281 
282 STDMETHODIMP CQGAVssProvider::DeleteSnapshots(
283     VSS_ID SourceObjectId, VSS_OBJECT_TYPE eSourceObjectType,
284     BOOL bForceDelete, LONG *plDeletedSnapshots, VSS_ID *pNondeletedSnapshotID)
285 {
286     *plDeletedSnapshots = 0;
287     *pNondeletedSnapshotID = SourceObjectId;
288     return S_OK;
289 }
290 
291 STDMETHODIMP CQGAVssProvider::BeginPrepareSnapshot(
292     VSS_ID SnapshotSetId, VSS_ID SnapshotId,
293     VSS_PWSZ pwszVolumeName, LONG lNewContext)
294 {
295     return S_OK;
296 }
297 
298 STDMETHODIMP CQGAVssProvider::IsVolumeSupported(
299     VSS_PWSZ pwszVolumeName, BOOL *pbSupportedByThisProvider)
300 {
301     HANDLE hEventFrozen;
302 
303     /* Check if a requester is qemu-ga by whether an event is created */
304     hEventFrozen = OpenEvent(EVENT_ALL_ACCESS, FALSE, EVENT_NAME_FROZEN);
305     if (!hEventFrozen) {
306         *pbSupportedByThisProvider = FALSE;
307         return S_OK;
308     }
309     CloseHandle(hEventFrozen);
310 
311     *pbSupportedByThisProvider = TRUE;
312     return S_OK;
313 }
314 
315 STDMETHODIMP CQGAVssProvider::IsVolumeSnapshotted(VSS_PWSZ pwszVolumeName,
316     BOOL *pbSnapshotsPresent, LONG *plSnapshotCompatibility)
317 {
318     *pbSnapshotsPresent = FALSE;
319     *plSnapshotCompatibility = 0;
320     return S_OK;
321 }
322 
323 STDMETHODIMP CQGAVssProvider::SetSnapshotProperty(VSS_ID SnapshotId,
324     VSS_SNAPSHOT_PROPERTY_ID eSnapshotPropertyId, VARIANT vProperty)
325 {
326     return E_NOTIMPL;
327 }
328 
329 STDMETHODIMP CQGAVssProvider::RevertToSnapshot(VSS_ID SnapshotId)
330 {
331     return E_NOTIMPL;
332 }
333 
334 STDMETHODIMP CQGAVssProvider::QueryRevertStatus(
335     VSS_PWSZ pwszVolume, IVssAsync **ppAsync)
336 {
337     return E_NOTIMPL;
338 }
339 
340 
341 /*
342  * IVssProviderCreateSnapshotSet methods
343  */
344 
345 STDMETHODIMP CQGAVssProvider::EndPrepareSnapshots(VSS_ID SnapshotSetId)
346 {
347     return S_OK;
348 }
349 
350 STDMETHODIMP CQGAVssProvider::PreCommitSnapshots(VSS_ID SnapshotSetId)
351 {
352     return S_OK;
353 }
354 
355 STDMETHODIMP CQGAVssProvider::CommitSnapshots(VSS_ID SnapshotSetId)
356 {
357     HRESULT hr = S_OK;
358     HANDLE hEventFrozen, hEventThaw, hEventTimeout;
359 
360     hEventFrozen = OpenEvent(EVENT_ALL_ACCESS, FALSE, EVENT_NAME_FROZEN);
361     if (!hEventFrozen) {
362         return E_FAIL;
363     }
364 
365     hEventThaw = OpenEvent(EVENT_ALL_ACCESS, FALSE, EVENT_NAME_THAW);
366     if (!hEventThaw) {
367         CloseHandle(hEventFrozen);
368         return E_FAIL;
369     }
370 
371     hEventTimeout = OpenEvent(EVENT_ALL_ACCESS, FALSE, EVENT_NAME_TIMEOUT);
372     if (!hEventTimeout) {
373         CloseHandle(hEventFrozen);
374         CloseHandle(hEventThaw);
375         return E_FAIL;
376     }
377 
378     /* Send event to qemu-ga to notify filesystem is frozen */
379     SetEvent(hEventFrozen);
380 
381     /* Wait until the snapshot is taken by the host. */
382     if (WaitForSingleObject(hEventThaw, VSS_TIMEOUT_MSEC) != WAIT_OBJECT_0) {
383         /* Send event to qemu-ga to notify the provider is timed out */
384         SetEvent(hEventTimeout);
385     }
386 
387     CloseHandle(hEventThaw);
388     CloseHandle(hEventFrozen);
389     CloseHandle(hEventTimeout);
390     return hr;
391 }
392 
393 STDMETHODIMP CQGAVssProvider::PostCommitSnapshots(
394     VSS_ID SnapshotSetId, LONG lSnapshotsCount)
395 {
396     return S_OK;
397 }
398 
399 STDMETHODIMP CQGAVssProvider::PreFinalCommitSnapshots(VSS_ID SnapshotSetId)
400 {
401     return S_OK;
402 }
403 
404 STDMETHODIMP CQGAVssProvider::PostFinalCommitSnapshots(VSS_ID SnapshotSetId)
405 {
406     return S_OK;
407 }
408 
409 STDMETHODIMP CQGAVssProvider::AbortSnapshots(VSS_ID SnapshotSetId)
410 {
411     return S_OK;
412 }
413 
414 /*
415  * IVssProviderNotifications methods
416  */
417 
418 STDMETHODIMP CQGAVssProvider::OnLoad(IUnknown *pCallback)
419 {
420     return S_OK;
421 }
422 
423 STDMETHODIMP CQGAVssProvider::OnUnload(BOOL bForceUnload)
424 {
425     return S_OK;
426 }
427 
428 
429 /*
430  * CQGAVssProviderFactory class
431  */
432 
433 class CQGAVssProviderFactory : public IClassFactory
434 {
435 public:
436     STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
437     STDMETHODIMP_(ULONG) AddRef();
438     STDMETHODIMP_(ULONG) Release();
439     STDMETHODIMP CreateInstance(
440         IUnknown *pUnknownOuter, REFIID iid, void **ppv);
441     STDMETHODIMP LockServer(BOOL lock) { return E_NOTIMPL; }
442 
443     CQGAVssProviderFactory();
444     ~CQGAVssProviderFactory();
445 
446 private:
447     long m_nRefCount;
448 };
449 
450 CQGAVssProviderFactory::CQGAVssProviderFactory()
451 {
452     m_nRefCount = 0;
453     LockModule(TRUE);
454 }
455 
456 CQGAVssProviderFactory::~CQGAVssProviderFactory()
457 {
458     LockModule(FALSE);
459 }
460 
461 STDMETHODIMP CQGAVssProviderFactory::QueryInterface(REFIID riid, void **ppv)
462 {
463     if (riid == IID_IUnknown || riid == IID_IClassFactory) {
464         *ppv = static_cast<void*>(this);
465         AddRef();
466         return S_OK;
467     }
468     *ppv = NULL;
469     return E_NOINTERFACE;
470 }
471 
472 STDMETHODIMP_(ULONG) CQGAVssProviderFactory::AddRef()
473 {
474     return InterlockedIncrement(&m_nRefCount);
475 }
476 
477 STDMETHODIMP_(ULONG) CQGAVssProviderFactory::Release()
478 {
479     long nRefCount = InterlockedDecrement(&m_nRefCount);
480     if (m_nRefCount == 0) {
481         delete this;
482     }
483     return nRefCount;
484 }
485 
486 STDMETHODIMP CQGAVssProviderFactory::CreateInstance(
487     IUnknown *pUnknownOuter, REFIID iid, void **ppv)
488 {
489     CQGAVssProvider *pObj;
490 
491     if (pUnknownOuter) {
492         return CLASS_E_NOAGGREGATION;
493     }
494     try {
495         pObj = new CQGAVssProvider;
496     } catch (...) {
497         return E_OUTOFMEMORY;
498     }
499     HRESULT hr = pObj->QueryInterface(iid, ppv);
500     if (FAILED(hr)) {
501         delete pObj;
502     }
503     return hr;
504 }
505 
506 
507 /*
508  * DLL functions
509  */
510 
511 STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
512 {
513     CQGAVssProviderFactory *factory;
514     try {
515         factory = new CQGAVssProviderFactory;
516     } catch (...) {
517         return E_OUTOFMEMORY;
518     }
519     factory->AddRef();
520     HRESULT hr = factory->QueryInterface(riid, ppv);
521     factory->Release();
522     return hr;
523 }
524 
525 STDAPI DllCanUnloadNow()
526 {
527     return g_nComObjsInUse == 0 ? S_OK : S_FALSE;
528 }
529 
530 EXTERN_C
531 BOOL WINAPI DllMain(HINSTANCE hinstDll, DWORD dwReason, LPVOID lpReserved)
532 {
533     qga_debug("begin, reason = %lu", dwReason);
534     if (dwReason == DLL_PROCESS_ATTACH) {
535         g_hinstDll = hinstDll;
536         DisableThreadLibraryCalls(hinstDll);
537     }
538     qga_debug_end;
539     return TRUE;
540 }
541