Changeset 13971 in vbox

Timestamp:

Nov 7, 2008 4:07:57 PM (16 years ago)

Author:

vboxsync

Message:

HostServices/GuestProperties: added blocking waits for notifications

Location:

trunk

Files:

• include/VBox/HostServices/GuestPropertySvc.h (modified) (2 diffs)
• src/VBox/HostServices/GuestProperties/service.cpp (modified) (13 diffs)
• src/VBox/HostServices/GuestProperties/testcase/tstGuestPropSvc.cpp (modified) (4 diffs)

trunk/include/VBox/HostServices/GuestPropertySvc.h

@@ -431 +431 @@
  * On success, VINF_SUCCESS will be returned and the buffer will contain
  * details of a property notification.  If no new notification is available,
- * a timestamp of zero will be returned.
+ * the call will block until one is.
  * If the last notification could not be found by timestamp, VWRN_NOT_FOUND
  * will be returned and the oldest available notification will be returned.
- * if no timestamp is specified, the oldest available notification will be
+ * If no timestamp is specified, the oldest available notification will be
  * returned.
  * If the buffer supplied was not large enough to hold the notification,
  * VERR_BUFFER_OVERFLOW will be returned and the size parameter will contain
  * the size of the buffer needed.
+ *
+ * The protocol for a guest to obtain notifications is to call
+ * GET_NOTIFICATION in a loop.  On the first call, the ingoing timestamp
+ * parameter should be set to zero.  On subsequent calls, it should be set to
+ * the outgoing timestamp from the previous call. 
  */
 typedef struct _GetNotification
@@ -452 +457 @@
      *
      * The timestamp of the change being notified of (OUT uint64_t)
-     * If this is zero then no new events are available.  Undefined on
-     * failure.
+     * Undefined on failure.
      */
     HGCMFunctionParameter timestamp;
 
     /**
-     * The returned data. if any will be placed here.  (OUT pointer)
+     * The returned data, if any, will be placed here.  (OUT pointer)
      * This call returns three null-terminated strings which will be placed
      * one after another: name, value and flags.  For a delete notification,

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

@@ -60 +60 @@
 #include <string>
 #include <list>
+#include <vector>
 
 namespace guestProp {
@@ -104 +105 @@
     /** The list of property changes for guest notifications */
     PropertyList mGuestNotifications;
+    /** Structure for holding an uncompleted guest call */
+    struct GuestCall
+    {
+        /** The call handle */
+        VBOXHGCMCALLHANDLE mHandle;
+        /** The function that was requested */
+        uint32_t mFunction;
+        /** The number of parameters */
+        uint32_t mcParms;
+        /** The parameters themselves */
+        VBOXHGCMSVCPARM *mParms;
+
+        /** The standard constructor */
+        GuestCall() : mFunction(0), mcParms(0) {}
+        /** The normal contructor */
+        GuestCall(VBOXHGCMCALLHANDLE aHandle, uint32_t aFunction,
+                  uint32_t acParms, VBOXHGCMSVCPARM aParms[])
+                  : mHandle(aHandle), mFunction(aFunction), mcParms(acParms),
+                  mParms(aParms) {}
+    };
+    typedef std::vector <GuestCall> CallVector;
+    /** The list of outstanding guest notification calls */
+    CallVector mGuestWaiters;
     /** @todo we should have classes for thread and request handler thread */
     /** Queue of outstanding property change notifications */
@@ -213 +237 @@
     int delProperty(uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool isGuest);
     int enumProps(uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
-    int getNotification(uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
+    int getNotification(VBOXHGCMCALLHANDLE callHandle, uint32_t cParms,
+                        VBOXHGCMSVCPARM paParms[], bool canWait);
     void doNotifications(const char *pszProperty, uint64_t u64Timestamp);
     static DECLCALLBACK(int) reqNotify(PFNHGCMSVCEXT pfnCallback,
@@ -748 +773 @@
  * @param   cParms  the number of HGCM parameters supplied
  * @param   paParms the array of HGCM parameters
+ * @param   canWait can this request be enqueued
  * @thread  HGCM
- */
-int Service::getNotification(uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+ * @throws  can throw std::bad_alloc if canWait==true
+ */
+int Service::getNotification(VBOXHGCMCALLHANDLE callHandle, uint32_t cParms,
+                             VBOXHGCMSVCPARM paParms[], bool canWait)
 {
     int rc = VINF_SUCCESS;
@@ -817 +845 @@
 
     /*
-     * Write out the data.
-     */
-    paParms[0].setUInt64(u64Timestamp);
-    paParms[2].setUInt32(buffer.size());
-    if (RT_SUCCESS(rc) && buffer.size() <= cchBuf)
-        buffer.copy(pchBuf, cchBuf);
+     * Write out the data or add the caller to the notification list if there
+     * is no notification available.
+     */
+    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 = VINF_HGCM_ASYNC_EXECUTE;
+    }
     else if (RT_SUCCESS(rc))
-        rc = VERR_BUFFER_OVERFLOW;
-    if (RT_SUCCESS(rc) && warn)
-        rc = VWRN_NOT_FOUND;
+    {
+        AssertFailed();
+        rc = VERR_INTERNAL_ERROR;
+    }
     return rc;
 }
@@ -847 +890 @@
 
     AssertPtrReturnVoid(pszProperty);
+    /* Ensure that our timestamp is different to the last one. */
+    if (   !mGuestNotifications.empty()
+        && u64Timestamp == mGuestNotifications.back().mTimestamp)
+        ++u64Timestamp;
+
+    /*
+     * Try to find the property.
+     */
     PropertyList::const_iterator it;
     bool found = false;
@@ -856 +907 @@
                 break;
             }
+
     /*
      * First case: if the property exists then send its current value
@@ -874 +926 @@
                              (PFNRT)Service::reqNotify, 7, mpfnHostCallback,
                              mpvHostData, pszName, pszValue,
-                             (uint32_t) RT_HIDWORD(it->mTimestamp),
-                             (uint32_t) RT_LODWORD(it->mTimestamp), pszFlags);
+                             (uint32_t) RT_HIDWORD(u64Timestamp),
+                             (uint32_t) RT_LODWORD(u64Timestamp), pszFlags);
 #endif /* VBOX_GUEST_PROP_TEST_NOTHREAD not defined */
     }
     if (found)
     {
-        /* Add the change to the queue for guest notifications */
+        /* Add the change to the queue for guest notifications and release
+         * waiters */
         if (RT_SUCCESS(rc))
         {
@@ -886 +939 @@
             {
                 mGuestNotifications.push_back(*it);
+                while (mGuestWaiters.size() > 0)
+                {
+                    GuestCall call = mGuestWaiters.back();
+                    int rc2 = getNotification(call.mHandle, call.mcParms,
+                                              call.mParms, false);
+                    mpHelpers->pfnCallComplete (call.mHandle, rc2);
+                    mGuestWaiters.pop_back();
+                }
             }
             catch (std::bad_alloc)
@@ -980 +1041 @@
 {
     int rc = VINF_SUCCESS;
-    bool fCallSync = true;
-
     LogFlowFunc(("u32ClientID = %d, fn = %d, cParms = %d, pparms = %d\n",
                  u32ClientID, eFunction, cParms, paParms));
@@ -1022 +1081 @@
             case GET_NOTIFICATION:
                 LogFlowFunc(("GET_NOTIFICATION\n"));
-                rc = getNotification(cParms, paParms);
+                rc = getNotification(callHandle, cParms, paParms, true);
                 break;
 
@@ -1033 +1092 @@
         rc = VERR_NO_MEMORY;
     }
-    if (fCallSync)
-    {
-        LogFlowFunc(("rc = %Rrc\n", rc));
+    LogFlowFunc(("rc = %Rrc\n", rc));
+    if (rc != VINF_HGCM_ASYNC_EXECUTE)
+    {
         mpHelpers->pfnCallComplete (callHandle, rc);
     }
@@ -1176 +1235 @@
                 ptable->pfnCall               = Service::svcCall;
                 ptable->pfnHostCall           = Service::svcHostCall;
-                ptable->pfnSaveState          = NULL;  /* The service is stateless by definition, so the */
-                ptable->pfnLoadState          = NULL;  /* normal construction done before restoring suffices */
+                ptable->pfnSaveState          = NULL;  /* The service is stateless, so the normal */
+                ptable->pfnLoadState          = NULL;  /* construction done before restoring suffices */
                 ptable->pfnRegisterExtension  = Service::svcRegisterExtension;
 

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

@@ -735 +735 @@
     }
 
-    /* Test when no new events are available */
-    pTable->pfnCall(pTable->pvService, &callHandle, 0, NULL,
-                    GET_NOTIFICATION, 3, paParms);
-    if (   RT_FAILURE(callHandle.rc)
-        || RT_FAILURE(paParms[0].getUInt64 (&u64Timestamp))
-        || u64Timestamp != 0
-       )
-    {
-        RTPrintf("Failed to signal properly that no new notifications are available.\n");
-        rc = VERR_UNRESOLVED_ERROR;
-    }
-
     /* Test a query with an unknown timestamp */
     paParms[0].setUInt64 (1);
@@ -775 +763 @@
  * @note    prints its own diagnostic information to stdout.
  */
-int testNoNotifications(VBOXHGCMSVCFNTABLE *pTable)
+int testNoNotifications(VBOXHGCMSVCFNTABLE *pTable, VBOXHGCMCALLHANDLE_TYPEDEF *callHandle,
+                        VBOXHGCMSVCPARM *paParms, char *pchBuffer, size_t cchBuffer)
 {
     int rc = VINF_SUCCESS;
-    VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
-    char chBuffer[MAX_NAME_LEN + MAX_VALUE_LEN + MAX_FLAGS_LEN];
-
-    RTPrintf("Testing the GET_NOTIFICATION call when no notifications are available.\n");
+
+    RTPrintf("Testing the asynchronous GET_NOTIFICATION call with no notifications are available.\n");
     uint64_t u64Timestamp = 0;
     uint32_t u32Size = 0;
-    VBOXHGCMSVCPARM paParms[3];
 
     paParms[0].setUInt64 (u64Timestamp);
-    paParms[1].setPointer ((void *) chBuffer, sizeof(chBuffer));
-    pTable->pfnCall(pTable->pvService, &callHandle, 0, NULL,
+    paParms[1].setPointer ((void *) pchBuffer, cchBuffer);
+    callHandle->rc = VINF_HGCM_ASYNC_EXECUTE;
+    pTable->pfnCall(pTable->pvService, callHandle, 0, NULL,
                     GET_NOTIFICATION, 3, paParms);
-    if (   RT_FAILURE(callHandle.rc)
-        || RT_FAILURE(paParms[0].getUInt64 (&u64Timestamp))
-        || u64Timestamp != 0
-       )
-    {
-        RTPrintf("Failed to signal properly that no new notifications are available.\n");
+    if (callHandle->rc != VINF_HGCM_ASYNC_EXECUTE)
+    {
+        RTPrintf("GET_NOTIFICATION call completed when new notifications should be available.\n");
         rc = VERR_UNRESOLVED_ERROR;
     }
@@ -805 +789 @@
     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);
     RTR3Init();
@@ -819 +808 @@
     if (RT_FAILURE(testEnumPropsHost(&svcTable)))
         return 1;
-    if (RT_FAILURE(testNoNotifications(&svcTable)))
+    /* Asynchronous notification call */
+    if (RT_FAILURE(testNoNotifications(&svcTable, &callHandleStruct, aParm,
+                   chBuffer, sizeof(chBuffer))))
         return 1;
     if (RT_FAILURE(testSetProp(&svcTable)))
         return 1;
+    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(testDelProp(&svcTable)))
         return 1;