qga/vss-win32/provider.cpp

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