Changeset 14104 in vbox for trunk/src/VBox

Timestamp:

Nov 11, 2008 7:16:32 PM (16 years ago)

Author:

vboxsync

Message:

HostServices/GuestProperties: fixed the GET_NOTIFICATION protocol

Location:

trunk/src/VBox/HostServices/GuestProperties

Files:

• service.cpp (modified) (14 diffs)
• testcase/Makefile.kmk (modified) (1 diff)
• testcase/tstGuestPropSvc.cpp (modified) (12 diffs)

trunk/src/VBox/HostServices/GuestProperties/service.cpp

@@ -60 +60 @@
 #include <string>
 #include <list>
-#include <vector>
 
 namespace guestProp {
@@ -112 +111 @@
         /** The function that was requested */
         uint32_t mFunction;
-        /** The number of parameters */
-        uint32_t mcParms;
-        /** The parameters themselves */
+        /** The call parameters */
         VBOXHGCMSVCPARM *mParms;
+        /** The default return value, used for passing warnings */
+        int mRc;
 
         /** The standard constructor */
-        GuestCall() : mFunction(0), mcParms(0) {}
+        GuestCall() : mFunction(0) {}
         /** The normal contructor */
         GuestCall(VBOXHGCMCALLHANDLE aHandle, uint32_t aFunction,
-                  uint32_t acParms, VBOXHGCMSVCPARM aParms[])
-                  : mHandle(aHandle), mFunction(aFunction), mcParms(acParms),
-                  mParms(aParms) {}
+                  VBOXHGCMSVCPARM aParms[], int aRc)
+                  : mHandle(aHandle), mFunction(aFunction), mParms(aParms),
+                    mRc(aRc) {}
     };
-    typedef std::vector <GuestCall> CallVector;
+    typedef std::list <GuestCall> CallList;
     /** The list of outstanding guest notification calls */
-    CallVector mGuestWaiters;
+    CallList mGuestWaiters;
     /** @todo we should have classes for thread and request handler thread */
     /** Queue of outstanding property change notifications */
@@ -238 +237 @@
     int enumProps(uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     int getNotification(VBOXHGCMCALLHANDLE callHandle, uint32_t cParms,
-                        VBOXHGCMSVCPARM paParms[], bool canWait);
+                        VBOXHGCMSVCPARM paParms[]);
+    int getOldNotification(const char *pszPattern, uint64_t u64Timestamp,
+                           Property *pProp);
+    int getNotificationWriteOut(VBOXHGCMSVCPARM paParms[], Property prop);
     void doNotifications(const char *pszProperty, uint64_t u64Timestamp);
     static DECLCALLBACK(int) reqNotify(PFNHGCMSVCEXT pfnCallback,
@@ -439 +441 @@
     char *pchBuf;
     uint32_t cchName, cchBuf;
-    size_t cchFlags, cchBufActual;
+    uint32_t cchFlags, cchBufActual;
     char szFlags[MAX_FLAGS_LEN];
-    uint32_t fFlags;
 
     /*
@@ -734 +735 @@
             char szFlags[MAX_FLAGS_LEN];
             char szTimestamp[256];
-            size_t cchTimestamp;
+            uint32_t cchTimestamp;
             buffer += it->mName;
             buffer += '\0';
@@ -768 +769 @@
 
 /**
+ * Get the next property change notification from the queue of saved
+ * notification based on the timestamp of the last notification seen.
+ * Notifications will only be reported if the property name matches the
+ * pattern given.
+ *
+ * @returns iprt status value
+ * @returns VWRN_NOT_FOUND if the last notification was not found in the queue
+ * @param   pszPatterns   the patterns to match the property name against
+ * @param   u64Timestamp  the timestamp of the last notification
+ * @param   pProp         where to return the property found.  If none is
+ *                        found this will be set to nil.
+ * @thread  HGCM
+ */
+int Service::getOldNotification(const char *pszPatterns, uint64_t u64Timestamp,
+                                Property *pProp)
+{
+    AssertPtrReturn(pszPatterns, VERR_INVALID_POINTER);
+    AssertReturn(u64Timestamp != 0, VERR_INVALID_PARAMETER);  /* Zero means wait for a new notification. */
+    AssertPtrReturn(pProp, VERR_INVALID_POINTER);
+    int rc = VINF_SUCCESS;
+    bool warn = false;
+
+    /* We count backwards, as the guest should normally be querying the
+     * most recent events. */
+    PropertyList::reverse_iterator it = mGuestNotifications.rbegin();
+    for (; it->mTimestamp != u64Timestamp && it != mGuestNotifications.rend();
+         ++it) {}
+    /* Warn if the timestamp was not found. */
+    if (it->mTimestamp != u64Timestamp)
+        warn = true;
+    /* Now look for an event matching the patterns supplied.  The base()
+     * member conveniently points to the following element. */
+    PropertyList::iterator base = it.base();
+    for (;    pszPatterns[0] != '\0'
+           && !RTStrSimplePatternMultiMatch(pszPatterns, RTSTR_MAX,
+                                            base->mName.c_str(), RTSTR_MAX,
+                                            NULL)
+           && base != mGuestNotifications.end(); ++base) {}
+    if (RT_SUCCESS(rc) && base != mGuestNotifications.end())
+        *pProp = *base;
+    else if (RT_SUCCESS(rc))
+        *pProp = Property();
+    if (warn)
+        rc = VWRN_NOT_FOUND;
+    return rc;
+}
+
+int Service::getNotificationWriteOut(VBOXHGCMSVCPARM paParms[], Property prop)
+{
+    int rc = VINF_SUCCESS;
+    /* Format the data to write to the buffer. */
+    std::string buffer;
+    uint64_t u64Timestamp;
+    char *pchBuf;
+    uint32_t cchBuf;
+    rc = paParms[2].getPointer((void **) &pchBuf, &cchBuf);
+    if (RT_SUCCESS(rc))
+    {
+        char szFlags[MAX_FLAGS_LEN];
+        rc = writeFlags(prop.mFlags, szFlags);
+        if (RT_SUCCESS(rc))
+        {
+            buffer += prop.mName;
+            buffer += '\0';
+            buffer += prop.mValue;
+            buffer += '\0';
+            buffer += szFlags;
+            buffer += '\0';
+            u64Timestamp = prop.mTimestamp;
+        }
+    }
+    /* Write out the data. */
+    if (RT_SUCCESS(rc))
+    {
+        paParms[1].setUInt64(u64Timestamp);
+        paParms[3].setUInt32(buffer.size());
+        if (buffer.size() <= cchBuf)
+            buffer.copy(pchBuf, cchBuf);
+        else
+            rc = VERR_BUFFER_OVERFLOW;
+    }
+    return rc;
+}
+
+/**
  * Get the next guest notification.
  *
@@ -773 +859 @@
  * @param   cParms  the number of HGCM parameters supplied
  * @param   paParms the array of HGCM parameters
- * @param   canWait can this request be enqueued
  * @thread  HGCM
- * @throws  can throw std::bad_alloc if canWait==true
+ * @throws  can throw std::bad_alloc
  */
 int Service::getNotification(VBOXHGCMCALLHANDLE callHandle, uint32_t cParms,
-                             VBOXHGCMSVCPARM paParms[], bool canWait)
-{
-    int rc = VINF_SUCCESS;
-    char *pchBuf;
-    uint32_t cchBuf = 0;
+                             VBOXHGCMSVCPARM paParms[])
+{
+    int rc = VINF_SUCCESS;
+    char *pszPatterns, *pchBuf;
+    uint32_t cchPatterns = 0, cchBuf = 0;
     uint64_t u64Timestamp;
-    bool warn = false;
 
     /*
@@ -790 +874 @@
      */
     LogFlowThisFunc(("\n"));
-    if (   (cParms != 3)  /* Hardcoded value as the next lines depend on it. */
-        || RT_FAILURE(paParms[0].getUInt64 (&u64Timestamp))  /* timestamp */
-        || RT_FAILURE(paParms[1].getPointer ((void **) &pchBuf, &cchBuf))  /* return buffer */
+    if (   (cParms != 4)  /* Hardcoded value as the next lines depend on it. */
+        || RT_FAILURE(paParms[0].getPointer ((void **) &pszPatterns, &cchPatterns))  /* patterns */
+        || pszPatterns[cchPatterns - 1] != '\0'  /* The patterns string must be zero-terminated */
+        || RT_FAILURE(paParms[1].getUInt64 (&u64Timestamp))  /* timestamp */
+        || RT_FAILURE(paParms[2].getPointer ((void **) &pchBuf, &cchBuf))  /* return buffer */
         || cchBuf < 1
        )
@@ -800 +886 @@
      * Find the change to notify of.
      */
-    Property next;
-    /* Return the oldest notification if no timestamp was specified. */
-    if (RT_SUCCESS(rc) && !mGuestNotifications.empty() && u64Timestamp == 0)
-        next = mGuestNotifications.front();
-    /* Only search if the guest hasn't seen the most recent notification. */
-    else if (   RT_SUCCESS(rc)
-             && !mGuestNotifications.empty()
-             && mGuestNotifications.back().mTimestamp != u64Timestamp)
-    {
-        /* We count backwards, as the guest should normally be querying the
-         * most recent events. */
-        PropertyList::reverse_iterator it = mGuestNotifications.rbegin();
-        for ( ;    it != mGuestNotifications.rend()
-                && it->mTimestamp != u64Timestamp;
-             ++it
-            ) {}
-        /* Warn if the timestamp was not found. */
-        if (it == mGuestNotifications.rend())
-            warn = true;
-        /* This is a reverse iterator, so --it goes up the list. */
-        --it;
-        next = *it;
-    }
-
-    /*
-     * Format the data to write to the buffer.
-     */
-    std::string buffer;
-    if (RT_SUCCESS(rc))
-    {
-        char szFlags[MAX_FLAGS_LEN];
-        rc = writeFlags(next.mFlags, szFlags);
-        if (RT_SUCCESS(rc))
-        {
-            buffer += next.mName;
-            buffer += '\0';
-            buffer += next.mValue;
-            buffer += '\0';
-            buffer += szFlags;
-            buffer += '\0';
-            u64Timestamp = next.mTimestamp;
-        }
-    }
-
-    /*
-     * Write out the data or add the caller to the notification list if there
-     * is no notification available.
-     */
+    Property prop;
     if (RT_SUCCESS(rc) && u64Timestamp != 0)
-    {
-        paParms[0].setUInt64(u64Timestamp);
-        paParms[2].setUInt32(buffer.size());
-        if (RT_SUCCESS(rc) && buffer.size() <= cchBuf)
-            buffer.copy(pchBuf, cchBuf);
-        else if (RT_SUCCESS(rc))
-            rc = VERR_BUFFER_OVERFLOW;
-        if (RT_SUCCESS(rc) && warn)
-            rc = VWRN_NOT_FOUND;
-    }
-    else if (RT_SUCCESS(rc) && canWait)
-    {
-        mGuestWaiters.push_back(GuestCall(callHandle, GET_NOTIFICATION, cParms,
-                                         paParms));
+        rc = getOldNotification(pszPatterns, u64Timestamp, &prop);
+    if (   (RT_SUCCESS(rc) && u64Timestamp == 0)
+        || (RT_SUCCESS(rc) && prop.mName.size() == 1)  /* Empty name -> not found */
+       )
+    {
+        mGuestWaiters.push_back(GuestCall(callHandle, GET_NOTIFICATION,
+                                          paParms, rc));
         rc = VINF_HGCM_ASYNC_EXECUTE;
     }
-    else if (RT_SUCCESS(rc))
-    {
-        AssertFailed();
-        rc = VERR_INTERNAL_ERROR;
+    else
+    {
+        int rc2 = getNotificationWriteOut(paParms, prop);
+        if (RT_FAILURE(rc2))
+            rc = rc2;
     }
     return rc;
@@ -885 +918 @@
 void Service::doNotifications(const char *pszProperty, uint64_t u64Timestamp)
 {
-    char szFlags[MAX_FLAGS_LEN];
     char *pszName = NULL, *pszValue = NULL, *pszFlags = NULL;
     int rc = VINF_SUCCESS;
@@ -898 +930 @@
      * Try to find the property.
      */
-    PropertyList::const_iterator it;
+    Property prop;
     bool found = false;
     if (RT_SUCCESS(rc))
-        for (it = mProperties.begin(); it != mProperties.end(); ++it)
+        for (PropertyList::const_iterator it = mProperties.begin();
+             !found && it != mProperties.end(); ++it)
             if (it->mName.compare(pszProperty) == 0)
             {
                 found = true;
-                break;
+                prop = *it;
             }
 
@@ -914 +947 @@
     {
 #ifndef VBOX_GUEST_PROP_TEST_NOTHREAD
+        char szFlags[MAX_FLAGS_LEN];
         /* Send out a host notification */
-        rc = writeFlags(it->mFlags, szFlags);
+        rc = writeFlags(prop.mFlags, szFlags);
         if (RT_SUCCESS(rc))
             rc = RTStrDupEx(&pszName, pszProperty);
         if (RT_SUCCESS(rc))
-            rc = RTStrDupEx(&pszValue, it->mValue.c_str());
+            rc = RTStrDupEx(&pszValue, prop.mValue.c_str());
         if (RT_SUCCESS(rc))
             rc = RTStrDupEx(&pszFlags, szFlags);
@@ -932 +966 @@
     if (found)
     {
-        /* Add the change to the queue for guest notifications and release
-         * waiters */
+        /* Release waiters if applicable and add the change to the queue for
+         * guest notifications */
         if (RT_SUCCESS(rc))
         {
             try
             {
-                mGuestNotifications.push_back(*it);
-                while (mGuestWaiters.size() > 0)
+                for (CallList::iterator it = mGuestWaiters.begin();
+                     it != mGuestWaiters.end(); ++it)
                 {
-                    GuestCall call = mGuestWaiters.back();
-                    int rc2 = getNotification(call.mHandle, call.mcParms,
-                                              call.mParms, false);
-                    mpHelpers->pfnCallComplete (call.mHandle, rc2);
-                    mGuestWaiters.pop_back();
+                    const char *pszPatterns;
+                    uint32_t cchPatterns;
+                    it->mParms[0].getPointer((void **) &pszPatterns, &cchPatterns);
+                    if (   pszPatterns[0] == '\0'
+                        || RTStrSimplePatternMultiMatch(pszPatterns, RTSTR_MAX,
+                                                        pszProperty, RTSTR_MAX,
+                                                        NULL))
+                    {
+                        GuestCall call = mGuestWaiters.back();
+                        int rc2 = getNotificationWriteOut(call.mParms, prop);
+                        if (RT_SUCCESS(rc2))
+                            rc2 = call.mRc;
+                        mpHelpers->pfnCallComplete (call.mHandle, rc2);
+                        it = mGuestWaiters.erase(it);
+                    }
                 }
+                mGuestNotifications.push_back(prop);
             }
             catch (std::bad_alloc)
@@ -1081 +1126 @@
             case GET_NOTIFICATION:
                 LogFlowFunc(("GET_NOTIFICATION\n"));
-                rc = getNotification(callHandle, cParms, paParms, true);
+                rc = getNotification(callHandle, cParms, paParms);
                 break;
 

trunk/src/VBox/HostServices/GuestProperties/testcase/Makefile.kmk

@@ -34 +34 @@
 tstGuestPropSvc_SOURCES  = tstGuestPropSvc.cpp ../service.cpp
 tstGuestPropSvc_LIBS     = $(LIB_RUNTIME)
+# For now!
+tstGuestPropSvc_CXXFLAGS.win = -EHsc
 
 # Set this in LocalConfig.kmk if you are working on the guest property service

trunk/src/VBox/HostServices/GuestProperties/testcase/tstGuestPropSvc.cpp

@@ -241 +241 @@
 
 /** Result string sizes for zeroth enumeration test */
-static const size_t cchEnumResult0[] =
+static const uint32_t cchEnumResult0[] =
 {
     sizeof("test/name/\0test/value/\0""0\0"),
@@ -254 +254 @@
  * the - 1 at the end is because of the hidden zero terminator
  */
-static const size_t cchEnumBuffer0 =
+static const uint32_t cchEnumBuffer0 =
 sizeof("test/name/\0test/value/\0""0\0\0"
 "test name\0test value\0""999\0TRANSIENT, READONLY\0"
@@ -269 +269 @@
 
 /** Result string sizes for first and second enumeration test */
-static const size_t cchEnumResult1[] =
+static const uint32_t cchEnumResult1[] =
 {
     sizeof("TEST NAME\0TEST VALUE\0""999999\0RDONLYHOST"),
@@ -280 +280 @@
  * the - 1 at the end is because of the hidden zero terminator
  */
-static const size_t cchEnumBuffer1 =
+static const uint32_t cchEnumBuffer1 =
 sizeof("TEST NAME\0TEST VALUE\0""999999\0RDONLYHOST\0"
 "/test/name\0/test/value\0""999999999999\0RDONLYGUEST\0\0\0\0\0") - 1;
@@ -289 +289 @@
     const char *pcszPatterns;
     /** The size of the pattern string */
-    const size_t cchPatterns;
+    const uint32_t cchPatterns;
     /** The expected enumeration output strings */
     const char **ppcchResult;
     /** The size of the output strings */
-    const size_t *pcchResult;
+    const uint32_t *pcchResult;
     /** The size of the buffer needed for the enumeration */
-    const size_t cchBuffer;
+    const uint32_t cchBuffer;
 }
 enumStrings[] =
@@ -693 +693 @@
     VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
     char chBuffer[MAX_NAME_LEN + MAX_VALUE_LEN + MAX_FLAGS_LEN];
+    static char szPattern[] = "";
 
     RTPrintf("Testing the GET_NOTIFICATION call.\n");
-    uint64_t u64Timestamp = 0;
+    uint64_t u64Timestamp;
     uint32_t u32Size = 0;
-    VBOXHGCMSVCPARM paParms[3];
+    VBOXHGCMSVCPARM paParms[4];
 
     /* Test "buffer too small" */
-    paParms[0].setUInt64 (u64Timestamp);
-    paParms[1].setPointer ((void *) chBuffer, getNotifications[0].cchBuffer - 1);
+    u64Timestamp = 1;
+    paParms[0].setPointer ((void *) szPattern, sizeof(szPattern));
+    paParms[1].setUInt64 (u64Timestamp);
+    paParms[2].setPointer ((void *) chBuffer, getNotifications[0].cchBuffer - 1);
     pTable->pfnCall(pTable->pvService, &callHandle, 0, NULL,
-                    GET_NOTIFICATION, 3, paParms);
+                    GET_NOTIFICATION, 4, paParms);
     if (   callHandle.rc != VERR_BUFFER_OVERFLOW
-        || RT_FAILURE(paParms[2].getUInt32 (&u32Size))
+        || RT_FAILURE(paParms[3].getUInt32 (&u32Size))
         || u32Size != getNotifications[0].cchBuffer
        )
@@ -714 +717 @@
     }
 
-    /* Test successful notification queries */
+    /* Test successful notification queries.  Start with an unknown timestamp
+     * to get the oldest available notification. */
+    u64Timestamp = 1;
     for (unsigned i = 0; RT_SUCCESS(rc) && (getNotifications[i].pchBuffer != NULL);
          ++i)
     {
-        paParms[0].setUInt64 (u64Timestamp);
-        paParms[1].setPointer ((void *) chBuffer, sizeof(chBuffer));
+        paParms[0].setPointer ((void *) szPattern, sizeof(szPattern));
+        paParms[1].setUInt64 (u64Timestamp);
+        paParms[2].setPointer ((void *) chBuffer, sizeof(chBuffer));
         pTable->pfnCall(pTable->pvService, &callHandle, 0, NULL,
-                        GET_NOTIFICATION, 3, paParms);
+                        GET_NOTIFICATION, 4, paParms);
         if (   RT_FAILURE(callHandle.rc)
-            || RT_FAILURE(paParms[0].getUInt64 (&u64Timestamp))
-            || RT_FAILURE(paParms[2].getUInt32 (&u32Size))
+            || (i == 0 && callHandle.rc != VWRN_NOT_FOUND)
+            || RT_FAILURE(paParms[1].getUInt64 (&u64Timestamp))
+            || RT_FAILURE(paParms[3].getUInt32 (&u32Size))
             || u32Size != getNotifications[i].cchBuffer
             || memcmp(chBuffer, getNotifications[i].pchBuffer, u32Size) != 0
@@ -734 +741 @@
         }
     }
-
-    /* Test a query with an unknown timestamp */
-    paParms[0].setUInt64 (1);
-    paParms[1].setPointer ((void *) chBuffer, sizeof(chBuffer));
-    if (RT_SUCCESS(rc))
-        pTable->pfnCall(pTable->pvService, &callHandle, 0, NULL,
-                        GET_NOTIFICATION, 3, paParms);
-    if (   RT_SUCCESS(rc)
-        && (   callHandle.rc != VWRN_NOT_FOUND
-            || RT_FAILURE(callHandle.rc)
-            || RT_FAILURE(paParms[0].getUInt64 (&u64Timestamp))
-            || RT_FAILURE(paParms[2].getUInt32 (&u32Size))
-            || u32Size != getNotifications[0].cchBuffer
-            || memcmp(chBuffer, getNotifications[0].pchBuffer, u32Size) != 0
-           )
-       )
-    {
-        RTPrintf("Problem getting notification for property '%s' with unknown timestamp, rc=%Rrc.\n",
-                 getNotifications[0].pchBuffer, callHandle.rc);
-        rc = VERR_UNRESOLVED_ERROR;
-    }
     return rc;
 }
 
-/**
- * Test the GET_NOTIFICATION function when no notifications are available.
+/** Paramters for the asynchronous guest notification call */
+struct asyncNotification_
+{
+    /** Call parameters */
+    VBOXHGCMSVCPARM aParms[4];
+    /** Result buffer */
+    char chBuffer[MAX_NAME_LEN + MAX_VALUE_LEN + MAX_FLAGS_LEN];
+    /** Return value */
+    VBOXHGCMCALLHANDLE_TYPEDEF callHandle;
+} asyncNotification;
+
+/**
+ * Set up the test for the asynchronous GET_NOTIFICATION function.
  * @returns iprt status value to indicate whether the test went as expected.
  * @note    prints its own diagnostic information to stdout.
  */
-int testNoNotifications(VBOXHGCMSVCFNTABLE *pTable, VBOXHGCMCALLHANDLE_TYPEDEF *callHandle,
-                        VBOXHGCMSVCPARM *paParms, char *pchBuffer, size_t cchBuffer)
+int setupAsyncNotification(VBOXHGCMSVCFNTABLE *pTable)
 {
     int rc = VINF_SUCCESS;
@@ -771 +767 @@
     uint64_t u64Timestamp = 0;
     uint32_t u32Size = 0;
-
-    paParms[0].setUInt64 (u64Timestamp);
-    paParms[1].setPointer ((void *) pchBuffer, cchBuffer);
-    callHandle->rc = VINF_HGCM_ASYNC_EXECUTE;
-    pTable->pfnCall(pTable->pvService, callHandle, 0, NULL,
-                    GET_NOTIFICATION, 3, paParms);
-    if (callHandle->rc != VINF_HGCM_ASYNC_EXECUTE)
-    {
-        RTPrintf("GET_NOTIFICATION call completed when new notifications should be available.\n");
+    static char szPattern[] = "";
+
+    asyncNotification.aParms[0].setPointer ((void *) szPattern, sizeof(szPattern));
+    asyncNotification.aParms[1].setUInt64 (u64Timestamp);
+    asyncNotification.aParms[2].setPointer ((void *) asyncNotification.chBuffer,
+                                            sizeof(asyncNotification.chBuffer));
+    asyncNotification.callHandle.rc = VINF_HGCM_ASYNC_EXECUTE;
+    pTable->pfnCall(pTable->pvService, &asyncNotification.callHandle, 0, NULL,
+                    GET_NOTIFICATION, 4, asyncNotification.aParms);
+    if (RT_FAILURE(asyncNotification.callHandle.rc))
+    {
+        RTPrintf("GET_NOTIFICATION call failed, rc=%Rrc.\n", asyncNotification.callHandle.rc);
+        rc = VERR_UNRESOLVED_ERROR;
+    }
+    else if (asyncNotification.callHandle.rc != VINF_HGCM_ASYNC_EXECUTE)
+    {
+        RTPrintf("GET_NOTIFICATION call completed when no new notifications should be available.\n");
+        rc = VERR_UNRESOLVED_ERROR;
+    }
+    return rc;
+}
+
+/**
+ * Test the asynchronous GET_NOTIFICATION function.
+ * @returns iprt status value to indicate whether the test went as expected.
+ * @note    prints its own diagnostic information to stdout.
+ */
+int testAsyncNotification(VBOXHGCMSVCFNTABLE *pTable)
+{
+    int rc = VINF_SUCCESS;
+    uint64_t u64Timestamp;
+    uint32_t u32Size;
+    if (   asyncNotification.callHandle.rc != VINF_SUCCESS
+        || RT_FAILURE(asyncNotification.aParms[1].getUInt64 (&u64Timestamp))
+        || RT_FAILURE(asyncNotification.aParms[3].getUInt32 (&u32Size))
+        || u32Size != getNotifications[0].cchBuffer
+        || memcmp(asyncNotification.chBuffer, getNotifications[0].pchBuffer, u32Size) != 0
+       )
+    {
+        RTPrintf("Asynchronous GET_NOTIFICATION call did not complete as expected, rc=%Rrc\n",
+                 asyncNotification.callHandle.rc);
         rc = VERR_UNRESOLVED_ERROR;
     }
@@ -789 +817 @@
     VBOXHGCMSVCFNTABLE svcTable;
     VBOXHGCMSVCHELPERS svcHelpers;
-    /* Paramters for the asynchronous guest notification call */
-    VBOXHGCMSVCPARM aParm[3];
-    char chBuffer[MAX_NAME_LEN + MAX_VALUE_LEN + MAX_FLAGS_LEN];
-    VBOXHGCMCALLHANDLE_TYPEDEF callHandleStruct;
 
     initTable(&svcTable, &svcHelpers);
@@ -808 +832 @@
     if (RT_FAILURE(testEnumPropsHost(&svcTable)))
         return 1;
-    /* Asynchronous notification call */
-    if (RT_FAILURE(testNoNotifications(&svcTable, &callHandleStruct, aParm,
-                   chBuffer, sizeof(chBuffer))))
+    /* Set up the asynchronous notification test */
+    if (RT_FAILURE(setupAsyncNotification(&svcTable)))
         return 1;
     if (RT_FAILURE(testSetProp(&svcTable)))
@@ -816 +839 @@
     RTPrintf("Checking the data returned by the asynchronous notification call.\n");
     /* Our previous notification call should have completed by now. */
-    uint64_t u64Timestamp;
-    uint32_t u32Size;
-    if (   callHandleStruct.rc != VINF_SUCCESS
-        || RT_FAILURE(aParm[0].getUInt64 (&u64Timestamp))
-        || RT_FAILURE(aParm[2].getUInt32 (&u32Size))
-        || u32Size != getNotifications[0].cchBuffer
-        || memcmp(chBuffer, getNotifications[0].pchBuffer, u32Size) != 0
-       )
-    {
-        RTPrintf("Asynchronous GET_NOTIFICATION call did not complete as expected, rc=%Rrc\n",
-                 callHandleStruct.rc);
-        return 1;
-    }
+    if (RT_FAILURE(testAsyncNotification(&svcTable)))
+        return 1;
     if (RT_FAILURE(testDelProp(&svcTable)))
         return 1;