Changeset 57766 in vbox for trunk/src

Timestamp:

Sep 15, 2015 3:37:33 PM (9 years ago)

Author:

vboxsync

Message:

HostServices/GuestProperties: asynch host notifications.

File:

• trunk/src/VBox/HostServices/GuestProperties/service.cpp (modified) (9 diffs)

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

@@ -58 +58 @@
 #include <string>
 #include <list>
+
+/** @todo Delete the old !ASYNC_HOST_NOTIFY code and remove this define. */
+#define ASYNC_HOST_NOTIFY
 
 namespace guestProp {
@@ -287 +290 @@
         , mPrevTimestamp(0)
         , mcTimestampAdjustments(0)
+#ifdef ASYNC_HOST_NOTIFY
+        , mhThreadNotifyHost(NIL_RTTHREAD)
+        , mhReqQNotifyHost(NIL_RTREQQUEUE)
+#endif
     { }
 
@@ -365 +372 @@
         return VINF_SUCCESS;
     }
+
+#ifdef ASYNC_HOST_NOTIFY
+    int initialize();
+#endif
 
 private:
@@ -392 +403 @@
     void dbgInfoShow(PCDBGFINFOHLP pHlp);
     static DECLCALLBACK(void) dbgInfo(void *pvUser, PCDBGFINFOHLP pHlp, const char *pszArgs);
+
+#ifdef ASYNC_HOST_NOTIFY
+    /* Thread for handling host notifications. */
+    RTTHREAD mhThreadNotifyHost;
+    /* Queue for handling requests for notifications. */
+    RTREQQUEUE mhReqQNotifyHost;
+    static DECLCALLBACK(int) threadNotifyHost(RTTHREAD self, void *pvUser);
+#endif
 };
 
@@ -1208 +1227 @@
 }
 
+#ifdef ASYNC_HOST_NOTIFY
+static DECLCALLBACK(void) notifyHostAsyncWorker(PFNHGCMSVCEXT pfnHostCallback,
+                                                void *pvHostData,
+                                                HOSTCALLBACKDATA *pHostCallbackData)
+{
+    pfnHostCallback(pvHostData, 0 /*u32Function*/,
+                   (void *)pHostCallbackData,
+                   sizeof(HOSTCALLBACKDATA));
+    RTMemFree(pHostCallbackData);
+}
+#endif
+
 /**
  * Notify the service owner that a property has been added/deleted/changed.
@@ -1221 +1252 @@
     LogFlowFunc(("pszName=%s, pszValue=%s, u64Timestamp=%llu, pszFlags=%s\n",
                  pszName, pszValue, u64Timestamp, pszFlags));
+#ifdef ASYNC_HOST_NOTIFY
+    int rc = VINF_SUCCESS;
+
+    /* Allocate buffer for the callback data and strings. */
+    size_t cbName = pszName? strlen(pszName): 0;
+    size_t cbValue = pszValue? strlen(pszValue): 0;
+    size_t cbFlags = pszFlags? strlen(pszFlags): 0;
+    size_t cbAlloc = sizeof(HOSTCALLBACKDATA) + cbName + cbValue + cbFlags + 3;
+    HOSTCALLBACKDATA *pHostCallbackData = (HOSTCALLBACKDATA *)RTMemAlloc(cbAlloc);
+    if (pHostCallbackData)
+    {
+        uint8_t *pu8 = (uint8_t *)pHostCallbackData;
+        pu8 += sizeof(HOSTCALLBACKDATA);
+
+        pHostCallbackData->u32Magic     = HOSTCALLBACKMAGIC;
+
+        pHostCallbackData->pcszName     = (const char *)pu8;
+        memcpy(pu8, pszName, cbName);
+        pu8 += cbName;
+        *pu8++ = 0;
+
+        pHostCallbackData->pcszValue    = (const char *)pu8;
+        memcpy(pu8, pszValue, cbValue);
+        pu8 += cbValue;
+        *pu8++ = 0;
+
+        pHostCallbackData->u64Timestamp = u64Timestamp;
+
+        pHostCallbackData->pcszFlags    = (const char *)pu8;
+        memcpy(pu8, pszFlags, cbFlags);
+        pu8 += cbFlags;
+        *pu8++ = 0;
+
+        rc = RTReqQueueCallEx(mhReqQNotifyHost, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
+                              (PFNRT)notifyHostAsyncWorker, 3,
+                              mpfnHostCallback, mpvHostData, pHostCallbackData);
+        if (RT_FAILURE(rc))
+        {
+            RTMemFree(pHostCallbackData);
+        }
+    }
+    else
+    {
+        rc = VERR_NO_MEMORY;
+    }
+#else
     HOSTCALLBACKDATA HostCallbackData;
     HostCallbackData.u32Magic     = HOSTCALLBACKMAGIC;
@@ -1230 +1307 @@
                               (void *)(&HostCallbackData),
                               sizeof(HostCallbackData));
+#endif
     LogFlowFunc(("returning rc=%Rrc\n", rc));
     return rc;
@@ -1440 +1518 @@
 }
 
+#ifdef ASYNC_HOST_NOTIFY
+/* static */
+DECLCALLBACK(int) Service::threadNotifyHost(RTTHREAD self, void *pvUser)
+{
+    Service *pThis = (Service *)pvUser;
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("ENTER: %p\n", pThis));
+
+    for (;;)
+    {
+        rc = RTReqQueueProcess(pThis->mhReqQNotifyHost, RT_INDEFINITE_WAIT);
+
+        AssertMsg(rc == VWRN_STATE_CHANGED,
+                  ("Left RTReqProcess and error code is not VWRN_STATE_CHANGED rc=%Rrc\n",
+                   rc));
+        if (rc == VWRN_STATE_CHANGED)
+        {
+            break;
+        }
+    }
+
+    LogFlowFunc(("LEAVE: %Rrc\n", rc));
+    return rc;
+}
+
+static DECLCALLBACK(int) wakeupNotifyHost(void)
+{
+    /* Returning a VWRN_* will cause RTReqQueueProcess return. */
+    return VWRN_STATE_CHANGED;
+}
+
+int Service::initialize()
+{
+    /* The host notification thread and queue. */
+    int rc = RTReqQueueCreate(&mhReqQNotifyHost);
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTThreadCreate(&mhThreadNotifyHost,
+                            threadNotifyHost,
+                            this,
+                            0 /* default stack size */,
+                            RTTHREADTYPE_DEFAULT,
+                            0, /* no flags. */
+                            "GSTPROPNTFY");
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        if (mhReqQNotifyHost != NIL_RTREQQUEUE)
+        {
+            RTReqQueueDestroy(mhReqQNotifyHost);
+            mhReqQNotifyHost = NIL_RTREQQUEUE;
+        }
+    }
+
+    return rc;
+}
+#endif
+
 int Service::uninit()
 {
+#ifdef ASYNC_HOST_NOTIFY
+    if (mhReqQNotifyHost != NIL_RTREQQUEUE)
+    {
+        /* Stop the thread */
+        PRTREQ pReq;
+        int rc = RTReqQueueCall(mhReqQNotifyHost, &pReq, 10000, (PFNRT)wakeupNotifyHost, 0);
+        if (RT_SUCCESS(rc))
+            RTReqRelease(pReq);
+
+        rc = RTReqQueueDestroy(mhReqQNotifyHost);
+        AssertRC(rc);
+        mhReqQNotifyHost = NIL_RTREQQUEUE;
+        mhThreadNotifyHost = NIL_RTTHREAD;
+    }
+#endif
+
     return VINF_SUCCESS;
 }
@@ -1501 +1655 @@
                 /* Service specific initialization. */
                 ptable->pvService = pService;
+
+#ifdef ASYNC_HOST_NOTIFY
+                rc = pService->initialize();
+                if (RT_FAILURE(rc))
+                {
+                    delete pService;
+                    pService = NULL;
+                }
+#endif
             }
             else